This is the log4cl Reference Manual, version 1.1.4, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 05:57:41 2024 GMT+0.
log4cl/log4cl.asdlog4cl/src/impl-package.lisplog4cl/src/defs.lisplog4cl/src/naming.lisplog4cl/src/naming-sbcl.lisplog4cl/src/hierarchy-base.lisplog4cl/src/hierarchy.lisplog4cl/src/logger.lisplog4cl/src/logging-macros.lisplog4cl/src/self-logger.lisplog4cl/appender/layout.lisplog4cl/appender/simple-layout.lisplog4cl/appender/pattern-layout.lisplog4cl/appender/appender-base.lisplog4cl/appender/appender.lisplog4cl/configuration/configurator.lisplog4cl/configuration/property-parser.lisplog4cl/configuration/property-configurator.lisplog4cl/watcher/watcher.lisplog4cl/client-package/package.lispThe main system appears first, followed by any subsystem dependency.
log4cl1.1.4
bordeaux-threads (system).
sb-posix (system).
src (module).
appender (module).
configuration (module).
watcher (module).
client-package (module).
Modules are listed depth-first from the system components tree.
log4cl/srclog4cl (system).
impl-package.lisp (file).
defs.lisp (file).
naming.lisp (file).
naming-sbcl.lisp (file).
hierarchy-base.lisp (file).
hierarchy.lisp (file).
logger.lisp (file).
logging-macros.lisp (file).
self-logger.lisp (file).
log4cl/appendersrc (module).
log4cl (system).
layout.lisp (file).
simple-layout.lisp (file).
pattern-layout.lisp (file).
appender-base.lisp (file).
appender.lisp (file).
log4cl/configurationlog4cl (system).
configurator.lisp (file).
property-parser.lisp (file).
property-configurator.lisp (file).
log4cl/watcherlog4cl (system).
watcher.lisp (file).
log4cl/client-packagesrc (module).
configuration (module).
log4cl (system).
package.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
log4cl/log4cl.asdlog4cl/src/impl-package.lisplog4cl/src/defs.lisplog4cl/src/naming.lisplog4cl/src/naming-sbcl.lisplog4cl/src/hierarchy-base.lisplog4cl/src/hierarchy.lisplog4cl/src/logger.lisplog4cl/src/logging-macros.lisplog4cl/src/self-logger.lisplog4cl/appender/layout.lisplog4cl/appender/simple-layout.lisplog4cl/appender/pattern-layout.lisplog4cl/appender/appender-base.lisplog4cl/appender/appender.lisplog4cl/configuration/configurator.lisplog4cl/configuration/property-parser.lisplog4cl/configuration/property-configurator.lisplog4cl/watcher/watcher.lisplog4cl/client-package/package.lisplog4cl/src/defs.lispimpl-package.lisp (file).
src (module).
*log-indent* (special variable).
*logger-truename* (special variable).
*ndc-context* (special variable).
+log-level-debu1+ (constant).
+log-level-debu2+ (constant).
+log-level-debu3+ (constant).
+log-level-debu4+ (constant).
+log-level-debu5+ (constant).
+log-level-debu6+ (constant).
+log-level-debu7+ (constant).
+log-level-debu8+ (constant).
+log-level-debu9+ (constant).
+log-level-debug+ (constant).
+log-level-error+ (constant).
+log-level-fatal+ (constant).
+log-level-info+ (constant).
+log-level-off+ (constant).
+log-level-trace+ (constant).
+log-level-unset+ (constant).
+log-level-warn+ (constant).
+max-log-level+ (constant).
+min-log-level+ (constant).
log4cl-error (function).
log4cl-error (condition).
*inside-user-log-function* (special variable).
*log-event-package-hint* (special variable).
*log-event-time* (special variable).
+log-level-from-letter+ (special variable).
+log-level-from-string+ (special variable).
+log-level-macro-symbols+ (special variable).
+log-level-symbols+ (special variable).
+log-level-to-keyword+ (special variable).
+log-level-to-lc-string+ (special variable).
+log-level-to-string+ (special variable).
+logger-after-package-flag+ (constant).
+logger-category-depth-bits+ (constant).
check-arg (function).
log4cl-style-warning (function).
log4cl-style-warning (condition).
logger-cat-idx (type).
log4cl/src/naming.lispdefs.lisp (file).
src (module).
*default-naming-configuration* (special variable).
*naming-configuration* (special variable).
+expr-format-fancy+ (special variable).
+expr-format-simple+ (special variable).
category-case (function).
category-separator (function).
enclosing-scope-block-name (generic function).
expr-print-format (function).
fix-method-spec-list (function).
join-categories (function).
log-level-from-object (generic function).
make-package-categories (function).
naming-configuration (class).
naming-option (generic function).
old-logging-macros (function).
package-wrapper (generic function).
resolve-logger-form (generic function).
with-package-naming-configuration (macro).
%category-case (reader method).
(setf %category-case) (writer method).
%category-separator (reader method).
(setf %category-separator) (writer method).
%expr-log-level (reader method).
(setf %expr-log-level) (writer method).
%expr-print-format (reader method).
(setf %expr-print-format) (writer method).
%old-logging-macros (reader method).
(setf %old-logging-macros) (writer method).
%use-shortest-nickname (reader method).
(setf %use-shortest-nickname) (writer method).
*dotted-naming-configuration* (special variable).
*naming-configurations* (special variable).
dotted-package-p (function).
ensure-naming-configuration (function).
expr-log-level (function).
find-or-create-naming-configuration (function).
instantiate-logger (function).
make-log-expr-format (function).
resolve-default-logger-form (generic function).
shortest-package-name (function).
use-shortest-nickname (function).
write-string-modify-case (function).
log4cl/src/naming-sbcl.lispnaming.lisp (file).
src (module).
enclosing-scope-block-name (method).
include-block-debug-name? (function).
safe-intern (function).
sbcl-get-block-name (function).
log4cl/src/hierarchy-base.lispnaming-sbcl.lisp (file).
src (module).
*hierarchy* (special variable).
watch-token-check (generic function).
*hierarchies* (special variable).
*hierarchy-lock* (special variable).
*hierarchy-max* (special variable).
*hierarchy-watcher-heartbeat* (special variable).
*name-to-hierarchy* (special variable).
*watcher-event-time* (special variable).
*watcher-thread* (special variable).
hierarchy (class).
watch-tokens (reader method).
(setf watch-tokens) (writer method).
log4cl/src/hierarchy.lisphierarchy-base.lisp (file).
src (module).
add-watch-token (function).
hierarchy-index (function).
remove-watch-token (function).
%hierarchy-index (function).
current-hierarchy (function).
with-hierarchies-lock (macro).
with-hierarchy-lock (macro).
log4cl/src/logger.lisphierarchy.lisp (file).
src (module).
%get-logger (function).
*root-logger* (special variable).
add-appender (function).
appender-added (method).
appender-removed (method).
effective-appenders (function).
effective-log-level (function).
inherited-log-level (function).
log-level-to-string (function).
logger-additivity (function).
(setf logger-additivity) (function).
logger-ancestors (function).
logger-appenders (function).
logger-categories (function).
logger-category (function).
logger-children (function).
logger-depth (function).
logger-descendants (function).
logger-file (function).
logger-file-logger (function).
logger-file-namestring (function).
logger-log-level (function).
(setf logger-log-level) (function).
logger-name (function).
logger-parent (function).
make-load-form (method).
make-log-level (function).
map-logger-children (function).
map-logger-descendants (function).
print-object (method).
print-object (method).
print-object (method).
remove-all-appenders (function).
remove-appender (function).
set-log-level (function).
%%create-root-logger (function).
%create-root-logger (function).
%logger-category (reader).
(setf %logger-category) (writer).
%logger-category-separator (reader).
(setf %logger-category-separator) (writer).
%logger-child-hash (reader).
(setf %logger-child-hash) (writer).
%logger-depth (reader).
(setf %logger-depth) (writer).
%logger-name-start-pos (reader).
(setf %logger-name-start-pos) (writer).
%logger-parent (reader).
(setf %logger-parent) (writer).
%logger-state (reader).
(setf %logger-state) (writer).
add-appender-internal (function).
adjust-all-loggers-state (function).
adjust-logger (function).
call-user-log-message (function).
copy-file-logger (function).
copy-logger (function).
copy-logger-state (function).
copy-root-logger (function).
copy-source-file-logger (function).
create-file-logger (function).
create-logger (function).
create-source-file-logger (function).
current-state (function).
define-category-depth-accessor (macro).
expand-log-with-level (function).
file-logger (structure).
file-logger-category (function).
(setf file-logger-category) (function).
file-logger-category-separator (function).
(setf file-logger-category-separator) (function).
file-logger-child-hash (function).
(setf file-logger-child-hash) (function).
file-logger-depth (function).
(setf file-logger-depth) (function).
file-logger-file (reader).
(setf file-logger-file) (writer).
file-logger-name-start-pos (function).
(setf file-logger-name-start-pos) (function).
file-logger-p (function).
file-logger-parent (function).
(setf file-logger-parent) (function).
file-logger-state (function).
(setf file-logger-state) (function).
have-appenders-for-level (function).
is-enabled-for (function).
log-event-time (function).
log-level-to-lc-string (function).
log-with-logger (function).
logger (structure).
logger-category-separator (function).
logger-child-hash (function).
logger-first-after-package-p (function).
logger-flags-depth (function).
logger-flags-pkg-idx-end (function).
logger-flags-pkg-idx-start (function).
logger-name-length (function).
logger-name-start-pos (function).
logger-p (function).
logger-pkg-idx-end (function).
logger-pkg-idx-start (function).
logger-state (function).
logger-state (structure).
logger-state-additivity (reader).
(setf logger-state-additivity) (writer).
logger-state-appenders (reader).
(setf logger-state-appenders) (writer).
logger-state-level (reader).
(setf logger-state-level) (writer).
logger-state-mask (reader).
(setf logger-state-mask) (writer).
logger-state-p (function).
make-logger-flags (function).
make-logger-state (function).
package-ref-sym (constant).
remove-all-appenders-internal (function).
remove-appender-internal (function).
root-logger (structure).
root-logger-category (function).
(setf root-logger-category) (function).
root-logger-category-separator (function).
(setf root-logger-category-separator) (function).
root-logger-child-hash (function).
(setf root-logger-child-hash) (function).
root-logger-depth (function).
(setf root-logger-depth) (function).
root-logger-dummy (reader).
(setf root-logger-dummy) (writer).
root-logger-name-start-pos (function).
(setf root-logger-name-start-pos) (function).
root-logger-p (function).
root-logger-parent (function).
(setf root-logger-parent) (function).
root-logger-state (function).
(setf root-logger-state) (function).
set-additivity (function).
source-file-logger (structure).
source-file-logger-category (function).
(setf source-file-logger-category) (function).
source-file-logger-category-separator (function).
(setf source-file-logger-category-separator) (function).
source-file-logger-child-hash (function).
(setf source-file-logger-child-hash) (function).
source-file-logger-depth (function).
(setf source-file-logger-depth) (function).
source-file-logger-file (reader).
(setf source-file-logger-file) (writer).
source-file-logger-name-start-pos (function).
(setf source-file-logger-name-start-pos) (function).
source-file-logger-namestring (reader).
(setf source-file-logger-namestring) (writer).
source-file-logger-p (function).
source-file-logger-parent (function).
(setf source-file-logger-parent) (function).
source-file-logger-state (function).
(setf source-file-logger-state) (function).
split-into-categories (function).
split-string (function).
strip-whitespace (function).
substr (function).
log4cl/src/logging-macros.lisplogger.lisp (file).
src (module).
in-log-hierarchy (macro).
in-package-log-hierarchy (macro).
log-debu1 (macro).
log-debu2 (macro).
log-debu3 (macro).
log-debu4 (macro).
log-debu5 (macro).
log-debu6 (macro).
log-debu7 (macro).
log-debu8 (macro).
log-debu9 (macro).
log-debug (macro).
log-error (macro).
log-fatal (macro).
log-info (macro).
log-sexp (macro).
log-sexp-debu1 (macro).
log-sexp-debu2 (macro).
log-sexp-debu3 (macro).
log-sexp-debu4 (macro).
log-sexp-debu5 (macro).
log-sexp-debu6 (macro).
log-sexp-debu7 (macro).
log-sexp-debu8 (macro).
log-sexp-debu9 (macro).
log-sexp-debug (macro).
log-sexp-error (macro).
log-sexp-fatal (macro).
log-sexp-info (macro).
log-sexp-trace (macro).
log-sexp-warn (macro).
log-sexp-with-level (macro).
log-trace (macro).
log-warn (macro).
make-logger (macro).
with-log-hierarchy (macro).
with-log-indent (macro).
with-ndc (macro).
with-package-log-hierarchy (macro).
+make-logger-symbols+ (special variable).
deflog-macros (macro).
deflog-sexp-macros (macro).
log4cl/src/self-logger.lisplogging-macros.lisp (file).
src (module).
+self-logger+ (special variable).
+self-meta-logger+ (special variable).
*self-log-config* (special variable).
log4cl/appender/layout.lispappender (module).
layout (class).
layout-to-stream (generic function).
property-alist (method).
log4cl/appender/simple-layout.lisplayout.lisp (file).
appender (module).
layout-to-stream (method).
simple-layout (class).
write-log-level (function).
log4cl/appender/pattern-layout.lispsimple-layout.lisp (file).
appender (module).
conversion-pattern (reader method).
(setf conversion-pattern) (writer method).
(setf conversion-pattern) (method).
layout-to-stream (method).
pattern-layout (class).
pattern-layout-error (function).
pattern-layout-error (condition).
shared-initialize (method).
*formatters* (special variable).
+default-local-date-format+ (special variable).
adjusted-logger-depth (function).
compile-pattern (function).
compile-pattern-format (function).
define-pattern-formatter (macro).
format-at-flag (reader method).
format-case (reader method).
format-categories (function).
format-categories-range (function).
format-colon-flag (reader method).
format-conversion-char (reader method).
format-date-format (reader method).
format-info (class).
format-log-date (function).
format-margin (reader method).
format-max-len (reader method).
format-min-len (reader method).
format-package (reader method).
format-precision (reader method).
format-prefix (reader method).
format-pretty (reader method).
format-right-justify (reader method).
format-separator (reader method).
format-start (reader method).
format-string (function).
format-suffix (reader method).
format-time (generic function).
format-universal-time (reader method).
format-utc-p (reader method).
kw= (function).
log-event-package (function).
parse-category-extra-args (function).
parse-category-precision (function).
parse-date-format-extra-args (function).
parse-extra-args (generic function).
parse-extra-args-in-curly-braces (function).
pattern-category-format-info (class).
pattern-date-format-info (class).
pattern-hostname-format-info (class).
pattern-log-indent-fmt-info (class).
pattern-pretty-fmt-info (class).
process-id-fmt-info (class).
property-alist (method).
simple-format-catogories (function).
with-small-dynamic-extent-vector (macro).
log4cl/appender/appender-base.lisppattern-layout.lisp (file).
appender (module).
appender (class).
appender-added (generic function).
appender-do-append (generic function).
appender-do-flush (generic function).
appender-enabled-p (reader method).
(setf appender-enabled-p) (writer method).
appender-error-count (reader method).
(setf appender-error-count) (writer method).
appender-ignored-error-count (reader method).
(setf appender-ignored-error-count) (writer method).
appender-last-error (reader method).
(setf appender-last-error) (writer method).
appender-last-ignored-error (reader method).
(setf appender-last-ignored-error) (writer method).
appender-layout (reader method).
(setf appender-layout) (writer method).
appender-logger-count (reader method).
(setf appender-logger-count) (writer method).
appender-loggers (reader method).
(setf appender-loggers) (writer method).
appender-message-count (reader method).
(setf appender-message-count) (writer method).
appender-removed (generic function).
close-appender (generic function).
handle-appender-error (generic function).
save-appender (generic function).
appender-filter (reader method).
(setf appender-filter) (writer method).
property-alist (generic function).
property-initarg-from-string (generic function).
log4cl/appender/appender.lispappender-base.lisp (file).
appender (module).
appender-added (method).
appender-do-append (method).
appender-do-append (method).
appender-do-append (method).
appender-do-append (method).
appender-do-append (method).
appender-do-append (method).
appender-do-append (method).
appender-do-flush (method).
appender-filename (generic reader).
appender-last-backup-file (generic reader).
appender-next-backup-file (generic reader).
appender-removed (method).
appender-stream (generic function).
(setf appender-stream) (writer method).
(setf appender-stream) (writer method).
backup-log-file (generic function).
close-appender (method).
close-appender (method).
console-appender (class).
counting-appender (class).
daily-file-appender (class).
file-appender (class).
file-appender-base (class).
fixed-stream-appender (class).
flush-all-appenders (function).
flush-appender (function).
handle-appender-error (method).
handle-appender-error (method).
maybe-roll-file (generic function).
rolling-file-appender-base (class).
save-appender (method).
save-appender (method).
serialized-appender (class).
shared-initialize (method).
slot-unbound (method).
stream-appender (class).
temp-appender (class).
temp-appender-error-type (reader method).
(setf temp-appender-error-type) (writer method).
this-console-appender (class).
tricky-console-appender (class).
watch-token-check (method).
create-appender-file (function).
expand-name-format (function).
fixed-stream-appender-base (class).
log-appender-disabled (function).
maybe-close-stream (function).
maybe-flush-appender-stream (function).
next-time-boundary (function).
property-alist (method).
property-alist (method).
property-alist (method).
property-alist (method).
property-alist (method).
property-alist (method).
property-alist (method).
resolve-stream (function).
save-all-appenders (function).
log4cl/configuration/configurator.lispconfiguration (module).
*configurations-file* (special variable).
*max-configurations* (special variable).
*save-configurations-to-file* (special variable).
all-configurations (function).
clear-logging-configuration (function).
configuration (class).
configuration-element (class).
list-configurations (function).
log-config (function).
print-object (method).
print-object (method).
reset-logging-configuration (function).
restore (function).
same-configuration-p (function).
save (function).
%set-package-options (function).
*configurations* (special variable).
*default-patterns* (special variable).
appender-extra-print-properties (function).
apply-logging-configuration (function).
auto-named-p (function).
elements-of (reader method).
(setf elements-of) (writer method).
figure-out-pattern (function).
level-of (reader method).
logger-of (reader method).
make-autosave-configuration (function).
make-logger-configuration-load-form (function).
maybe-restore-configurations (function).
name-of (reader method).
(setf name-of) (writer method).
package-options (macro).
perform-default-init (function).
read-configurations-from-file (function).
remember-logging-configuration (function).
replace-in-string (function).
save-configuration (function).
save-configurations-to-file (function).
show-logger-settings (function).
trim-configuration-list (function).
log4cl/configuration/property-parser.lispconfigurator.lisp (file).
configuration (module).
parse-property-stream (generic function).
property-parser (class).
property-parser-error (condition).
shared-initialize (method).
%parse-line (special variable).
%parse-line-num (special variable).
condition-of (reader method).
(setf condition-of) (writer method).
convert-read-case (function).
line-num-of (reader method).
(setf line-num-of) (writer method).
line-of (reader method).
(setf line-of) (writer method).
parse-property-keyword (generic function).
parse-property-line (generic function).
parse-property-tokens (generic function).
property-location (class).
with-property-location (macro).
log4cl/configuration/property-configurator.lispproperty-parser.lisp (file).
configuration (module).
configure (generic function).
parse-property-stream (method).
print-object (method).
property-configurator (class).
shared-initialize (method).
watch-token-check (method).
create-delayed-instance (function).
delayed-appender (class).
delayed-instance (class).
delayed-layout (class).
filespec-of (reader method).
(setf filespec-of) (writer method).
intern-boolean (function).
intern-class-name (function).
logger-record (class).
parse-logger-helper (function).
parse-property-keyword (method).
parse-property-keyword (method).
parse-property-keyword (method).
parse-property-keyword (method).
parse-property-keyword (method).
property-configurator-file-watch (class).
property-initarg-from-string (method).
set-delayed-instance-class (function).
set-delayed-instance-property (function).
log4cl/watcher/watcher.lispwatcher (module).
all-appenders (function).
start-hierarchy-watcher-thread (function).
stop-hierarchy-watcher-thread (function).
*stop-semaphore* (special variable).
*watcher-thread-bindings* (special variable).
call-with-logged-problems (function).
exit-hook (function).
hierarchy-watcher-do-one-token (function).
hierarchy-watcher-once (function).
init-hook (function).
maybe-start-watcher-thread (function).
save-hook (function).
start/stop-watcher-hook (function).
with-logged-problems (macro).
log4cl/client-package/package.lispclient-package (module).
log.
in-hierarchy (macro).
in-package-hierarchy (macro).
make (macro).
sexp-debu1 (macro).
sexp-debu2 (macro).
sexp-debu3 (macro).
sexp-debu4 (macro).
sexp-debu5 (macro).
sexp-debu6 (macro).
sexp-debu7 (macro).
sexp-debu8 (macro).
sexp-debu9 (macro).
sexp-debug (macro).
sexp-error (macro).
sexp-fatal (macro).
sexp-info (macro).
sexp-trace (macro).
sexp-warn (macro).
with-hierarchy (macro).
with-ndc-context (macro).
with-package-hierarchy (macro).
forward-function (macro).
forward-levels (macro).
forward-macro (macro).
forward-sexp-levels (macro).
Packages are listed by definition order.
logc (function).
category (macro).
config (function).
d (macro).
d1 (macro).
d2 (macro).
d3 (macro).
d4 (macro).
d5 (macro).
d6 (macro).
d7 (macro).
d8 (macro).
d9 (macro).
debu1 (macro).
debu2 (macro).
debu3 (macro).
debu4 (macro).
debu5 (macro).
debu6 (macro).
debu7 (macro).
debu8 (macro).
debu9 (macro).
debug (macro).
e (macro).
error (macro).
expr (macro).
f (macro).
fatal (macro).
i (macro).
in-hierarchy (macro).
in-package-hierarchy (macro).
info (macro).
make (macro).
pop (function).
push (function).
s (macro).
sexp (macro).
sexp-debu1 (macro).
sexp-debu2 (macro).
sexp-debu3 (macro).
sexp-debu4 (macro).
sexp-debu5 (macro).
sexp-debu6 (macro).
sexp-debu7 (macro).
sexp-debu8 (macro).
sexp-debu9 (macro).
sexp-debug (macro).
sexp-error (macro).
sexp-fatal (macro).
sexp-info (macro).
sexp-trace (macro).
sexp-warn (macro).
t (macro).
trace (macro).
w (macro).
warn (macro).
with-hierarchy (macro).
with-indent (macro).
with-package-hierarchy (macro).
log4cl-impllog4cl
common-lisp.
%get-logger (function).
*configurations-file* (special variable).
*default-naming-configuration* (special variable).
*hierarchy* (special variable).
*log-indent* (special variable).
*logger-truename* (special variable).
*max-configurations* (special variable).
*naming-configuration* (special variable).
*ndc-context* (special variable).
*root-logger* (special variable).
*save-configurations-to-file* (special variable).
+expr-format-fancy+ (special variable).
+expr-format-simple+ (special variable).
+log-level-debu1+ (constant).
+log-level-debu2+ (constant).
+log-level-debu3+ (constant).
+log-level-debu4+ (constant).
+log-level-debu5+ (constant).
+log-level-debu6+ (constant).
+log-level-debu7+ (constant).
+log-level-debu8+ (constant).
+log-level-debu9+ (constant).
+log-level-debug+ (constant).
+log-level-error+ (constant).
+log-level-fatal+ (constant).
+log-level-info+ (constant).
+log-level-off+ (constant).
+log-level-trace+ (constant).
+log-level-unset+ (constant).
+log-level-warn+ (constant).
+max-log-level+ (constant).
+min-log-level+ (constant).
+self-logger+ (special variable).
+self-meta-logger+ (special variable).
add-appender (function).
add-watch-token (function).
all-appenders (function).
all-configurations (function).
appender (class).
appender-added (generic function).
appender-do-append (generic function).
appender-do-flush (generic function).
appender-enabled-p (generic reader).
(setf appender-enabled-p) (generic writer).
appender-error-count (generic reader).
(setf appender-error-count) (generic writer).
appender-filename (generic reader).
appender-ignored-error-count (generic reader).
(setf appender-ignored-error-count) (generic writer).
appender-last-backup-file (generic reader).
appender-last-error (generic reader).
(setf appender-last-error) (generic writer).
appender-last-ignored-error (generic reader).
(setf appender-last-ignored-error) (generic writer).
appender-layout (generic reader).
(setf appender-layout) (generic writer).
appender-logger-count (generic reader).
(setf appender-logger-count) (generic writer).
appender-loggers (generic reader).
(setf appender-loggers) (generic writer).
appender-message-count (generic reader).
(setf appender-message-count) (generic writer).
appender-next-backup-file (generic reader).
appender-removed (generic function).
appender-stream (generic function).
(setf appender-stream) (generic writer).
backup-log-file (generic function).
category-case (function).
category-separator (function).
clear-logging-configuration (function).
close-appender (generic function).
configuration (class).
configuration-element (class).
configure (generic function).
console-appender (class).
conversion-pattern (generic reader).
(setf conversion-pattern) (generic function).
counting-appender (class).
daily-file-appender (class).
effective-appenders (function).
effective-log-level (function).
enclosing-scope-block-name (generic function).
expr-print-format (function).
file-appender (class).
file-appender-base (class).
fix-method-spec-list (function).
fixed-stream-appender (class).
flush-all-appenders (function).
flush-appender (function).
handle-appender-error (generic function).
hierarchy-index (function).
in-log-hierarchy (macro).
in-package-log-hierarchy (macro).
inherited-log-level (function).
join-categories (function).
layout (class).
layout-to-stream (generic function).
list-configurations (function).
log-config (function).
log-debu1 (macro).
log-debu2 (macro).
log-debu3 (macro).
log-debu4 (macro).
log-debu5 (macro).
log-debu6 (macro).
log-debu7 (macro).
log-debu8 (macro).
log-debu9 (macro).
log-debug (macro).
log-error (macro).
log-fatal (macro).
log-info (macro).
log-level-from-object (generic function).
log-level-to-string (function).
log-sexp (macro).
log-sexp-debu1 (macro).
log-sexp-debu2 (macro).
log-sexp-debu3 (macro).
log-sexp-debu4 (macro).
log-sexp-debu5 (macro).
log-sexp-debu6 (macro).
log-sexp-debu7 (macro).
log-sexp-debu8 (macro).
log-sexp-debu9 (macro).
log-sexp-debug (macro).
log-sexp-error (macro).
log-sexp-fatal (macro).
log-sexp-info (macro).
log-sexp-trace (macro).
log-sexp-warn (macro).
log-sexp-with-level (macro).
log-trace (macro).
log-warn (macro).
log4cl-error (function).
log4cl-error (condition).
logger-additivity (function).
(setf logger-additivity) (function).
logger-ancestors (function).
logger-appenders (function).
logger-categories (function).
logger-category (function).
logger-children (function).
logger-depth (function).
logger-descendants (function).
logger-file (function).
logger-file-logger (function).
logger-file-namestring (function).
logger-log-level (function).
(setf logger-log-level) (function).
logger-name (function).
logger-parent (function).
make-log-level (function).
make-logger (macro).
make-package-categories (function).
map-logger-children (function).
map-logger-descendants (function).
maybe-roll-file (generic function).
naming-configuration (class).
naming-option (generic function).
old-logging-macros (function).
package-wrapper (generic function).
parse-property-stream (generic function).
pattern-layout (class).
pattern-layout-error (function).
pattern-layout-error (condition).
property-configurator (class).
property-parser (class).
property-parser-error (condition).
remove-all-appenders (function).
remove-appender (function).
remove-watch-token (function).
reset-logging-configuration (function).
resolve-logger-form (generic function).
restore (function).
rolling-file-appender-base (class).
same-configuration-p (function).
save (function).
save-appender (generic function).
serialized-appender (class).
set-log-level (function).
simple-layout (class).
start-hierarchy-watcher-thread (function).
stop-hierarchy-watcher-thread (function).
stream-appender (class).
temp-appender (class).
temp-appender-error-type (generic reader).
(setf temp-appender-error-type) (generic writer).
this-console-appender (class).
tricky-console-appender (class).
watch-token-check (generic function).
with-log-hierarchy (macro).
with-log-indent (macro).
with-ndc (macro).
with-ndc-context (macro).
with-package-log-hierarchy (macro).
with-package-naming-configuration (macro).
%%create-root-logger (function).
%category-case (generic reader).
(setf %category-case) (generic writer).
%category-separator (generic reader).
(setf %category-separator) (generic writer).
%create-root-logger (function).
%expr-log-level (generic reader).
(setf %expr-log-level) (generic writer).
%expr-print-format (generic reader).
(setf %expr-print-format) (generic writer).
%hierarchy-index (function).
%logger-category (reader).
(setf %logger-category) (writer).
%logger-category-separator (reader).
(setf %logger-category-separator) (writer).
%logger-child-hash (reader).
(setf %logger-child-hash) (writer).
%logger-depth (reader).
(setf %logger-depth) (writer).
%logger-name-start-pos (reader).
(setf %logger-name-start-pos) (writer).
%logger-parent (reader).
(setf %logger-parent) (writer).
%logger-state (reader).
(setf %logger-state) (writer).
%old-logging-macros (generic reader).
(setf %old-logging-macros) (generic writer).
%parse-line (special variable).
%parse-line-num (special variable).
%set-package-options (function).
%use-shortest-nickname (generic reader).
(setf %use-shortest-nickname) (generic writer).
*configurations* (special variable).
*default-patterns* (special variable).
*dotted-naming-configuration* (special variable).
*formatters* (special variable).
*hierarchies* (special variable).
*hierarchy-lock* (special variable).
*hierarchy-max* (special variable).
*hierarchy-watcher-heartbeat* (special variable).
*inside-user-log-function* (special variable).
*log-event-package-hint* (special variable).
*log-event-time* (special variable).
*name-to-hierarchy* (special variable).
*naming-configurations* (special variable).
*self-log-config* (special variable).
*stop-semaphore* (special variable).
*watcher-event-time* (special variable).
*watcher-thread* (special variable).
*watcher-thread-bindings* (special variable).
+default-local-date-format+ (special variable).
+log-level-from-letter+ (special variable).
+log-level-from-string+ (special variable).
+log-level-macro-symbols+ (special variable).
+log-level-symbols+ (special variable).
+log-level-to-keyword+ (special variable).
+log-level-to-lc-string+ (special variable).
+log-level-to-string+ (special variable).
+logger-after-package-flag+ (constant).
+logger-category-depth-bits+ (constant).
+make-logger-symbols+ (special variable).
add-appender-internal (function).
adjust-all-loggers-state (function).
adjust-logger (function).
adjusted-logger-depth (function).
appender-extra-print-properties (function).
appender-filter (generic reader).
(setf appender-filter) (generic writer).
apply-logging-configuration (function).
auto-named-p (function).
call-user-log-message (function).
call-with-logged-problems (function).
check-arg (function).
compile-pattern (function).
compile-pattern-format (function).
condition-of (generic reader).
(setf condition-of) (generic writer).
convert-read-case (function).
copy-file-logger (function).
copy-logger (function).
copy-logger-state (function).
copy-root-logger (function).
copy-source-file-logger (function).
create-appender-file (function).
create-delayed-instance (function).
create-file-logger (function).
create-logger (function).
create-source-file-logger (function).
current-hierarchy (function).
current-state (function).
define-category-depth-accessor (macro).
define-pattern-formatter (macro).
deflog-macros (macro).
deflog-sexp-macros (macro).
delayed-appender (class).
delayed-instance (class).
delayed-layout (class).
dotted-package-p (function).
elements-of (generic reader).
(setf elements-of) (generic writer).
ensure-naming-configuration (function).
exit-hook (function).
expand-log-with-level (function).
expand-name-format (function).
expr-log-level (function).
figure-out-pattern (function).
file-logger (structure).
file-logger-category (function).
(setf file-logger-category) (function).
file-logger-category-separator (function).
(setf file-logger-category-separator) (function).
file-logger-child-hash (function).
(setf file-logger-child-hash) (function).
file-logger-depth (function).
(setf file-logger-depth) (function).
file-logger-file (reader).
(setf file-logger-file) (writer).
file-logger-name-start-pos (function).
(setf file-logger-name-start-pos) (function).
file-logger-p (function).
file-logger-parent (function).
(setf file-logger-parent) (function).
file-logger-state (function).
(setf file-logger-state) (function).
filespec-of (generic reader).
(setf filespec-of) (generic writer).
find-or-create-naming-configuration (function).
fixed-stream-appender-base (class).
format-at-flag (generic reader).
format-case (generic reader).
format-categories (function).
format-categories-range (function).
format-colon-flag (generic reader).
format-conversion-char (generic reader).
format-date-format (generic reader).
format-info (class).
format-log-date (function).
format-margin (generic reader).
format-max-len (generic reader).
format-min-len (generic reader).
format-package (generic reader).
format-precision (generic reader).
format-prefix (generic reader).
format-pretty (generic reader).
format-right-justify (generic reader).
format-separator (generic reader).
format-start (generic reader).
format-string (function).
format-suffix (generic reader).
format-time (generic function).
format-universal-time (generic reader).
format-utc-p (generic reader).
forward-function (macro).
forward-levels (macro).
forward-macro (macro).
forward-sexp-levels (macro).
get-logger-internal (function).
have-appenders-for-level (function).
hierarchy (class).
hierarchy-watcher-do-one-token (function).
hierarchy-watcher-once (function).
include-block-debug-name? (function).
init-hook (function).
instantiate-logger (function).
intern-boolean (function).
intern-class-name (function).
is-enabled-for (function).
kw= (function).
level-of (generic reader).
line-num-of (generic reader).
(setf line-num-of) (generic writer).
line-of (generic reader).
(setf line-of) (generic writer).
log-appender-disabled (function).
log-event-package (function).
log-event-time (function).
log-level-to-lc-string (function).
log-with-logger (function).
log4cl-style-warning (function).
log4cl-style-warning (condition).
logger (structure).
logger-cat-idx (type).
logger-category-separator (function).
logger-child-hash (function).
logger-first-after-package-p (function).
logger-flags-depth (function).
logger-flags-pkg-idx-end (function).
logger-flags-pkg-idx-start (function).
logger-name-length (function).
logger-name-start-pos (function).
logger-of (generic reader).
logger-p (function).
logger-pkg-idx-end (function).
logger-pkg-idx-start (function).
logger-record (class).
logger-state (function).
logger-state (structure).
logger-state-additivity (reader).
(setf logger-state-additivity) (writer).
logger-state-appenders (reader).
(setf logger-state-appenders) (writer).
logger-state-level (reader).
(setf logger-state-level) (writer).
logger-state-mask (reader).
(setf logger-state-mask) (writer).
logger-state-p (function).
make-autosave-configuration (function).
make-log-expr-format (function).
make-logger-configuration-load-form (function).
make-logger-flags (function).
make-logger-state (function).
maybe-close-stream (function).
maybe-flush-appender-stream (function).
maybe-restore-configurations (function).
maybe-start-watcher-thread (function).
name-of (generic reader).
(setf name-of) (generic writer).
next-time-boundary (function).
package-options (macro).
package-ref-sym (constant).
parse-category-extra-args (function).
parse-category-precision (function).
parse-date-format-extra-args (function).
parse-extra-args (generic function).
parse-extra-args-in-curly-braces (function).
parse-logger-helper (function).
parse-property-keyword (generic function).
parse-property-line (generic function).
parse-property-tokens (generic function).
pattern-category-format-info (class).
pattern-date-format-info (class).
pattern-hostname-format-info (class).
pattern-log-indent-fmt-info (class).
pattern-pretty-fmt-info (class).
perform-default-init (function).
process-id-fmt-info (class).
property-alist (generic function).
property-configurator-file-watch (class).
property-initarg-from-string (generic function).
property-location (class).
read-configurations-from-file (function).
remember-logging-configuration (function).
remove-all-appenders-internal (function).
remove-appender-internal (function).
replace-in-string (function).
resolve-default-logger-form (generic function).
resolve-stream (function).
root-logger (structure).
root-logger-category (function).
(setf root-logger-category) (function).
root-logger-category-separator (function).
(setf root-logger-category-separator) (function).
root-logger-child-hash (function).
(setf root-logger-child-hash) (function).
root-logger-depth (function).
(setf root-logger-depth) (function).
root-logger-dummy (reader).
(setf root-logger-dummy) (writer).
root-logger-name-start-pos (function).
(setf root-logger-name-start-pos) (function).
root-logger-p (function).
root-logger-parent (function).
(setf root-logger-parent) (function).
root-logger-state (function).
(setf root-logger-state) (function).
safe-intern (function).
save-all-appenders (function).
save-configuration (function).
save-configurations-to-file (function).
save-hook (function).
sbcl-get-block-name (function).
set-additivity (function).
set-delayed-instance-class (function).
set-delayed-instance-property (function).
shortest-package-name (function).
show-logger-settings (function).
simple-format-catogories (function).
source-file-logger (structure).
source-file-logger-category (function).
(setf source-file-logger-category) (function).
source-file-logger-category-separator (function).
(setf source-file-logger-category-separator) (function).
source-file-logger-child-hash (function).
(setf source-file-logger-child-hash) (function).
source-file-logger-depth (function).
(setf source-file-logger-depth) (function).
source-file-logger-file (reader).
(setf source-file-logger-file) (writer).
source-file-logger-name-start-pos (function).
(setf source-file-logger-name-start-pos) (function).
source-file-logger-namestring (reader).
(setf source-file-logger-namestring) (writer).
source-file-logger-p (function).
source-file-logger-parent (function).
(setf source-file-logger-parent) (function).
source-file-logger-state (function).
(setf source-file-logger-state) (function).
split-into-categories (function).
split-string (function).
start/stop-watcher-hook (function).
strip-whitespace (function).
substr (function).
trim-configuration-list (function).
use-shortest-nickname (function).
watch-tokens (generic reader).
(setf watch-tokens) (generic writer).
with-hierarchies-lock (macro).
with-hierarchy-lock (macro).
with-logged-problems (macro).
with-property-location (macro).
with-small-dynamic-extent-vector (macro).
write-log-level (function).
write-string-modify-case (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
The file where configurations will be saved. Is merged with result of USER-HOMEDIR-PATHNAME
Default naming configuration
Active hierarchy index. All logging functions use logger state indexed by this variable. Can be assigned directly or
Indent level can be used to indent logging info, is printed by %I pattern format
Will be used instead of *COMPILE-FILE-TRUENAME* or *LOAD-TRUENAME* when non-NIL to determine logger’s parent file logger.
Maximum number of configurations in *CONFIGURATIONS* list
Naming configuration currently in effect
Value that is printed by %x pattern format
The one and only root logger
When non-NIL SAVE will also write configurations to a *CONFIGURATIONS-FILE*
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Sets the *CURRENT-HIERARCHY* to specified hierarchy, or the default one when NIL
Sets the *CURRENT-HIERARCHY* to specified hierarchy, or the default one when NIL
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into LOG-<LEVEL> log statement that will print each element
of SEXPS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. Constant string elements will be output directly.
A pretty printer (pprint-newline :fill) format will be used as a
separator between expressions, so that long expressions start
on a new line, if *PRINT-PRETTY* is non-NIL
Example:
(let ((a 1) (b ’(two three))
(c (loop for i from 1 to 15 collect i)))
(log:sexp "values are" a b c))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
C=(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
Separator between expression and value, which defaults to equal sign, and a suffix after each value, which defaults to " ~:_" (a space followed by conditional newline) can be customized per package via NAMING-OPTION generic function
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Expands into the log statement that will print each
element of ARGS in the form of ELEMENT=VALUE where ELEMENT will be the
literal argument without evaluating it, and VALUE will be the result
of evaluation. For constant string elements, it is output literally
without printing its value.
Example:
(let ((a 1) (b ’(two three)))
(log-sexp "values are" a b))
will produce log message:
[debug] - values are A=1 B=(TWO THREE)
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Submit log message to the logging system. Whenever
the message is actually displayed or not depends on logging system
configuration at run-time.
The ARGS are parsed as follows:
1. Determine a logger object
If first argument is a constant list, constant symbol or a keyword, it
is made into a logger object as described in the MAKE-LOGGER macro
documentation
If first argument is a constant string, logger name is auto-determined
from context as described in the MAKE-LOGGER macro documentation, and
system proceeds to step 2.
Otherwise any non-NIL first argument is assumed to be a form, that
when evaluated will return a logger object.
2. If there are remaining arguments, they are used as format control
string and format arguments, to be passed into the FORMAT function to
produce the log message, when one is produced.
If there were no other arguments, then this macro expands into a form, that will return T or NIL depending if logging with specified log level will actually produce any log messages. Note that having log level enabled does not necessary mean logging with log level is enabled, it also takes into account whenever log message will reach any appenders.
Executes forms in BODY with *LOG-INDENT* set to INDENT
log.
Binds the *CURRENT-HIERARCHY* to the specified hierarchy for the dynamic scope of BODY. HIERARCHY can be hierarchy index or name
Executes forms in BODY with *LOG-INDENT* set to INDENT
Execute forms in BODY with *NDC-CONTEXT* set to CONTEXT. The context is printed by the %x pattern layout format
Binds the *CURRENT-HIERARCHY* to the unique hierarchy for the current package for the dynamic scope of BODY.
Retrieve or create a logger.
CATEGORIES – List of category names
SEPARATOR – Category separator. Will only be used if logger did not
exist before.
CAT-CASE – How each category case is treated. See NAMING-OPTION
generic function for description
FORCE-STRING-CASE – Whenever elements of category which are strings,
should also undergo case conversion according to CAT-CASE
CREATEP – Create the logger if it does not exist
FILE – pathname, source file being compiled
PKG-IDX-START/PKG-IDX-END – zero based indexes as to where
in CATEGORIES package name starts ends, meaning of indexes
is like SUBSEQ.. If package is unknown, both must be NIL
For historical reason the above indexes are incremented by one before
being stored in FLAGS slot, and functions LOGGER-PKG-IDX-START/END
return them 1 based, with 0 being used as a flag that there is no
package name in the category.
IS-FILE-P – T when its an actual SOURCE-FILE-LOGGER being requested, which is a special type of leaf logger representing the source file.
Adds appender to the logger
Add unique watch token to the HIERARCHY, uniqueness is determined
by TEST and KEY arguments which are passed to FIND and REMOVE. Any
matching token is already present, the old token is removed and new
one is inserted.
The per-hierarchy lock is held doing the operation.
Automatically starts hierarchy watcher thread, if it was not already started
Return all existing appenders in all hierarchies
Returns the *CONFIGURATIONS* list
Very DWIM oriented friendly way of configuring loggers and appenders.
(LOG:CONFIG [LOGGER-IDENTIFIER] OPTION1 OPTION2...)
LOGGER-IDENTIFIER is optional and defaults to the root logger. It can be
one of the following:
- Logger instance ie result of (LOG:CATEGORY) expansion, or any other form
that returns a logger.
- A list of logger categories, basically a shortcut for (LOG:CATEGORY
’(CAT1 CAT2 CAT3)). An error will be given if logger does not exist. If you want
to ensure logger is created, even if it did not exist before, use
(LOG:CONFIG (LOG:CATEGORY ...) ...)
Without any options (LOG:CONFIG) displays current configuration
—————|—————————————————————
Option | Description
—————|—————————————————————
MAIN OPTIONS.
—————|—————————————————————
:INFO | Or any other keyword identifying a log level, which can be
:DEBUG | shortened to its shortest unambiguous prefix, such as :D.
| Changes the logger level to that level.
—————|—————————————————————
:SANE | Removes logger appenders, then arranges for the logging output
| to be always logged to dynamic value of *TERMINAL-IO*
|
| If used with :DAILY then console appender is not added, unless
| :CONSOLE, :THIS-CONSOLE or :TRICKY-CONSOLE is also specified.
|
| The pattern layout added is affected by many of the pattern
| options below.
—————|—————————————————————
APPENDER OPTIONS
—————|—————————————————————
:CONSOLE | Adds CONSOLE-APPENDER to the logger. Console appender logs
| into current console as indicated by *TERMINAL-IO* stream
—————|—————————————————————
:THIS-CONSOLE | Adds THIS-CONSOLE-APPENDER to the logger. It captures the
(or :THIS) | current value of *TERMINAL-IO* by recursively resolving any
| synonym or two-way streams, and continues to log the
| remembered value, even if it goes out dynamic scope.
|
| On any stream errors it will auto-remove itself.
—————|—————————————————————
:TRICKY-CONSOLE| Adds TRICKY-CONSOLE-APPENDER which acts exactly like
(or :TRICKY) | THIS-CONSOLE appender above, but it checks if dynamic value
| of *TERMINAL-IO* resolves to the same stream and ignores the
| log message if it does.
|
| When debugging multi-threaded code from REPL, this results in
| REPL thread logging to REPL, while threads with some other
| value of *TERMINAL-IO* stream will output to both.
|
| As a shortcut, if THIS-CONSOLE is specified and global console
| appender already exists, it will add TRICKY-CONSOLE instead.
—————|—————————————————————
:SANE2 | Shortcut for :SANE :TRICKY (mnemonic two -> multiple threads)
—————|—————————————————————
:STREAM stream| Changes the stream used for above two dedicated stream
| appenders.
—————|—————————————————————
:DAILY FILE | Adds file appender logging to the named file, which will be
| re-opened every day, with old log file renamed to FILE.%Y%m%d.
|
| Removes any other file based appenders from the logger.
|
| FILE can also contain %Y%m%d like pattern, expansion of which
| will determine when new log file would be opened.
—————|—————————————————————
:FILTER level | Makes all appenders added by above keywords drop messages
| below specified level.
—————|—————————————————————
LAYOUT OPTIONS
General note about layout options, if any appender options are specified
the layout options only affect PATTERN-LAYOUT for new appenders created
by LOG:CONFIG command
But if no appender options are specified, but layout options are, LOG:CONFIG
will change the pattern layout on all console based appenders that output
current *TERMINAL-IO*
—————|—————————————————————
:PATTERN | For any new appenders added, specifies the conversion pattern
| for the PATTERN-LAYOUT. If not given, default pattern will be
| used, modified by below options
—————|—————————————————————
:PRETTY | Add {pretty} option to the pattern to force pretty printing
:NOPRETTY | Add {nopretty} option to the pattern to force no pretty printing
| without one of these, global value is in effect
—————|—————————————————————
:TIME/:NOTIME | Include time into default pattern, default is :TIME
—————|—————————————————————
:FILE or | Include file name into default pattern, :FILE2 uses alternate
:FILE2 | position for the file (in front of the package).
:NOFILE | :NOFILE does not show the file
—————|—————————————————————
:THREAD | Include thread name into default pattern, it will be after the
[<n>[<n2>]] | time, in [%t] format. If :THREAD argument is followed by one
| or two numbers, they will be used as min/max field width.
—————|—————————————————————
:NDC | Include NDC context into default pattern, with optional min/max
[<n>[<n2>]] | field width flags. When used together with :THREAD NDC will be
| printed after the thread name, separated by dash, like this
| example: "[threadname-ndc]"; it will not be shown if unbound
|
| Without :THREAD, its shown in its own square brackets, with
| entire construct not shown if unbound.
—————|—————————————————————
:NOPACKAGE | Add {nopackage} option to the pattern (binds orig package at
:PACKAGE | the site of the log statement. PACKAGE binds keyword package,
| so everything is printed with package prefix
—————|—————————————————————
:TWOLINE | Changes pattern layout to print hard newline before actual log
(or :2LINE) | message. Only makes sense with NOPRETTY or when logging into
| files.
|
| Pretty printing does better job at line splitting then forced
| two line layout, with short log statements placed on a single
| line and longer ones wrapping.
—————|—————————————————————
ASSORTED OTHER OPTIONS
—————|—————————————————————
:PROPERTIES | Configure with PROPERTY-CONFIGURATOR by parsing specified
FILE | properties file
—————|—————————————————————
:WATCH | Used with :PROPERTIES, uses watcher thread to check
| properties file modification time, and reloads if it changes
—————|—————————————————————
:IMMEDIATE- | Used with :SANE, :DAILY or :CONSOLE to create new appenders
FLUSH | with :IMMEDIATE-FLUSH T option, which prevents automatic
| startup of hierarchy watcher thread, which is used for
| auto-flushing.
—————|—————————————————————
:NOADDITIVE | Makes logger non-additive (does not propagate to parent)
:OWN | Shortcut for non-additive (usually has appenders on its own)
:ADDITIVE | Sets additive flag back to T.
—————|—————————————————————
:CLEAR | Reset the child in the hierarchy, by unsetting their log level
| and/or removing appenders from them. Without any other flags
| unset the log levels.
|
:LEVELS | Clears the log levels, this is the default
:APPENDERS | Removes any appenders, levels will not be cleared unless
| :LEVELS is also specified
|
:ALL | Normally :CLEAR does not touch non-additive loggers, that is
| the ones that don’t pass messages to parents. This flag forces
| clearing of non-additive loggers
|
| Note that this option does not change the logger being acted
| upon, just its children. See next option
—————|—————————————————————
:REMOVE <num> | Removes specific appender from the logger. Numbers are 1-based,
| and are same ones displayed by LOG:CONFIG without arguments
—————|—————————————————————
:SELF | Configures the LOG4CL logger, which can be used to debug
| Log4CL itself. Normally all other LOG:CONFIG hides the
| it from view.
—————|—————————————————————
:FORCE-ADD | Normally if you specify :CONSOLE :THIS-CONSOLE or
| :TRICKY-CONSOLE without :SANE (which clears out existing
| appenders), an error will be given if there are any standard
| console appenders that already log to *TERMINAL-IO* or :STREAM
| argument.
|
| This is to prevent from creating duplicate output.
|
| Adding :FORCE-ADD flag skips the above check, and allows you
| to add new console appender regardless.
—————|—————————————————————
:BACKUP | Used together with :DAILY, specifies the :BACKUP-NAME-FORMAT,
| see docstring for the DAILY-FILE-APPENDER class.
|
| For example specifying a DAILY <file> :BACKUP NIL will always
| log to statically named FILE without rolling.
|
| Defaults to NIL if FILE contains percent character or
| FILE.%Y%m%d otherwise.
—————|—————————————————————
Examples:
* (LOG:CONFIG :D) – Changes root logger level to debug
* (LOG:CONFIG :SANE) – Drops all console appenders, change level
to INFO, makes all output appear on current console
* (LOG:CONFIG :SANE2) – As above, but copy all other threads output
to current terminal.
* (LOG:CONFIG :PRETTY :THREAD) - changes active console appenders
layout to force pretty printing and add thread info.
* (LOG:CONFIG :NOPRETTY :PACKAGE) - changes layout to force no
pretty printing, and restoring original *PACKAGE* when printing
* (LOG:CONFIG :WARN :CLEAR) – Changes root logger level to warnings,
and unset child logger levels.
* (LOG:CONFIG ’(PACKAGE) :OWN :DEBUG :DAILY "package-log.%Y%m%d")
Configures the logger PACKAGE with debug log level, logging into
the file "package-log.20130510" which will be rolled over daily;
makes logger non-additive so messages will not be propagated to
logger parents. (To see them on console, remove the :OWN flag, or
add :CONSOLE to the command)
Note: in above example if package name is dotted, you need to
specify the split category list, so if your package name is
COM.EXAMPLE.FOO logger categories will be ’(COM EXAMPLE FOO)
log.
Delete all loggers configuration, leaving only LOG4CL-IMPL
Very DWIM oriented friendly way of configuring loggers and appenders.
(LOG:CONFIG [LOGGER-IDENTIFIER] OPTION1 OPTION2...)
LOGGER-IDENTIFIER is optional and defaults to the root logger. It can be
one of the following:
- Logger instance ie result of (LOG:CATEGORY) expansion, or any other form
that returns a logger.
- A list of logger categories, basically a shortcut for (LOG:CATEGORY
’(CAT1 CAT2 CAT3)). An error will be given if logger does not exist. If you want
to ensure logger is created, even if it did not exist before, use
(LOG:CONFIG (LOG:CATEGORY ...) ...)
Without any options (LOG:CONFIG) displays current configuration
—————|—————————————————————
Option | Description
—————|—————————————————————
MAIN OPTIONS.
—————|—————————————————————
:INFO | Or any other keyword identifying a log level, which can be
:DEBUG | shortened to its shortest unambiguous prefix, such as :D.
| Changes the logger level to that level.
—————|—————————————————————
:SANE | Removes logger appenders, then arranges for the logging output
| to be always logged to dynamic value of *TERMINAL-IO*
|
| If used with :DAILY then console appender is not added, unless
| :CONSOLE, :THIS-CONSOLE or :TRICKY-CONSOLE is also specified.
|
| The pattern layout added is affected by many of the pattern
| options below.
—————|—————————————————————
APPENDER OPTIONS
—————|—————————————————————
:CONSOLE | Adds CONSOLE-APPENDER to the logger. Console appender logs
| into current console as indicated by *TERMINAL-IO* stream
—————|—————————————————————
:THIS-CONSOLE | Adds THIS-CONSOLE-APPENDER to the logger. It captures the
(or :THIS) | current value of *TERMINAL-IO* by recursively resolving any
| synonym or two-way streams, and continues to log the
| remembered value, even if it goes out dynamic scope.
|
| On any stream errors it will auto-remove itself.
—————|—————————————————————
:TRICKY-CONSOLE| Adds TRICKY-CONSOLE-APPENDER which acts exactly like
(or :TRICKY) | THIS-CONSOLE appender above, but it checks if dynamic value
| of *TERMINAL-IO* resolves to the same stream and ignores the
| log message if it does.
|
| When debugging multi-threaded code from REPL, this results in
| REPL thread logging to REPL, while threads with some other
| value of *TERMINAL-IO* stream will output to both.
|
| As a shortcut, if THIS-CONSOLE is specified and global console
| appender already exists, it will add TRICKY-CONSOLE instead.
—————|—————————————————————
:SANE2 | Shortcut for :SANE :TRICKY (mnemonic two -> multiple threads)
—————|—————————————————————
:STREAM stream| Changes the stream used for above two dedicated stream
| appenders.
—————|—————————————————————
:DAILY FILE | Adds file appender logging to the named file, which will be
| re-opened every day, with old log file renamed to FILE.%Y%m%d.
|
| Removes any other file based appenders from the logger.
|
| FILE can also contain %Y%m%d like pattern, expansion of which
| will determine when new log file would be opened.
—————|—————————————————————
:FILTER level | Makes all appenders added by above keywords drop messages
| below specified level.
—————|—————————————————————
LAYOUT OPTIONS
General note about layout options, if any appender options are specified
the layout options only affect PATTERN-LAYOUT for new appenders created
by LOG:CONFIG command
But if no appender options are specified, but layout options are, LOG:CONFIG
will change the pattern layout on all console based appenders that output
current *TERMINAL-IO*
—————|—————————————————————
:PATTERN | For any new appenders added, specifies the conversion pattern
| for the PATTERN-LAYOUT. If not given, default pattern will be
| used, modified by below options
—————|—————————————————————
:PRETTY | Add {pretty} option to the pattern to force pretty printing
:NOPRETTY | Add {nopretty} option to the pattern to force no pretty printing
| without one of these, global value is in effect
—————|—————————————————————
:TIME/:NOTIME | Include time into default pattern, default is :TIME
—————|—————————————————————
:FILE or | Include file name into default pattern, :FILE2 uses alternate
:FILE2 | position for the file (in front of the package).
:NOFILE | :NOFILE does not show the file
—————|—————————————————————
:THREAD | Include thread name into default pattern, it will be after the
[<n>[<n2>]] | time, in [%t] format. If :THREAD argument is followed by one
| or two numbers, they will be used as min/max field width.
—————|—————————————————————
:NDC | Include NDC context into default pattern, with optional min/max
[<n>[<n2>]] | field width flags. When used together with :THREAD NDC will be
| printed after the thread name, separated by dash, like this
| example: "[threadname-ndc]"; it will not be shown if unbound
|
| Without :THREAD, its shown in its own square brackets, with
| entire construct not shown if unbound.
—————|—————————————————————
:NOPACKAGE | Add {nopackage} option to the pattern (binds orig package at
:PACKAGE | the site of the log statement. PACKAGE binds keyword package,
| so everything is printed with package prefix
—————|—————————————————————
:TWOLINE | Changes pattern layout to print hard newline before actual log
(or :2LINE) | message. Only makes sense with NOPRETTY or when logging into
| files.
|
| Pretty printing does better job at line splitting then forced
| two line layout, with short log statements placed on a single
| line and longer ones wrapping.
—————|—————————————————————
ASSORTED OTHER OPTIONS
—————|—————————————————————
:PROPERTIES | Configure with PROPERTY-CONFIGURATOR by parsing specified
FILE | properties file
—————|—————————————————————
:WATCH | Used with :PROPERTIES, uses watcher thread to check
| properties file modification time, and reloads if it changes
—————|—————————————————————
:IMMEDIATE- | Used with :SANE, :DAILY or :CONSOLE to create new appenders
FLUSH | with :IMMEDIATE-FLUSH T option, which prevents automatic
| startup of hierarchy watcher thread, which is used for
| auto-flushing.
—————|—————————————————————
:NOADDITIVE | Makes logger non-additive (does not propagate to parent)
:OWN | Shortcut for non-additive (usually has appenders on its own)
:ADDITIVE | Sets additive flag back to T.
—————|—————————————————————
:CLEAR | Reset the child in the hierarchy, by unsetting their log level
| and/or removing appenders from them. Without any other flags
| unset the log levels.
|
:LEVELS | Clears the log levels, this is the default
:APPENDERS | Removes any appenders, levels will not be cleared unless
| :LEVELS is also specified
|
:ALL | Normally :CLEAR does not touch non-additive loggers, that is
| the ones that don’t pass messages to parents. This flag forces
| clearing of non-additive loggers
|
| Note that this option does not change the logger being acted
| upon, just its children. See next option
—————|—————————————————————
:REMOVE <num> | Removes specific appender from the logger. Numbers are 1-based,
| and are same ones displayed by LOG:CONFIG without arguments
—————|—————————————————————
:SELF | Configures the LOG4CL logger, which can be used to debug
| Log4CL itself. Normally all other LOG:CONFIG hides the
| it from view.
—————|—————————————————————
:FORCE-ADD | Normally if you specify :CONSOLE :THIS-CONSOLE or
| :TRICKY-CONSOLE without :SANE (which clears out existing
| appenders), an error will be given if there are any standard
| console appenders that already log to *TERMINAL-IO* or :STREAM
| argument.
|
| This is to prevent from creating duplicate output.
|
| Adding :FORCE-ADD flag skips the above check, and allows you
| to add new console appender regardless.
—————|—————————————————————
:BACKUP | Used together with :DAILY, specifies the :BACKUP-NAME-FORMAT,
| see docstring for the DAILY-FILE-APPENDER class.
|
| For example specifying a DAILY <file> :BACKUP NIL will always
| log to statically named FILE without rolling.
|
| Defaults to NIL if FILE contains percent character or
| FILE.%Y%m%d otherwise.
—————|—————————————————————
Examples:
* (LOG:CONFIG :D) – Changes root logger level to debug
* (LOG:CONFIG :SANE) – Drops all console appenders, change level
to INFO, makes all output appear on current console
* (LOG:CONFIG :SANE2) – As above, but copy all other threads output
to current terminal.
* (LOG:CONFIG :PRETTY :THREAD) - changes active console appenders
layout to force pretty printing and add thread info.
* (LOG:CONFIG :NOPRETTY :PACKAGE) - changes layout to force no
pretty printing, and restoring original *PACKAGE* when printing
* (LOG:CONFIG :WARN :CLEAR) – Changes root logger level to warnings,
and unset child logger levels.
* (LOG:CONFIG ’(PACKAGE) :OWN :DEBUG :DAILY "package-log.%Y%m%d")
Configures the logger PACKAGE with debug log level, logging into
the file "package-log.20130510" which will be rolled over daily;
makes logger non-additive so messages will not be propagated to
logger parents. (To see them on console, remove the :OWN flag, or
add :CONSOLE to the command)
Note: in above example if package name is dotted, you need to
specify the split category list, so if your package name is
COM.EXAMPLE.FOO logger categories will be ’(COM EXAMPLE FOO)
log.
Return the list of all appenders that logger output could possible go to, including inherited one
Return logger’s own log level (if set) or the one it had inherited from parent
Flatten method specializer list, remove any T specializers, replace all constant EQL specializers with their values, and eliminate non-constant ones
Flush any appenders that had output since being flushed
Immediately flush the appender output if necessary, marking the time of the flush with TIME
Return the hierarchy index for the specified hierarchy. Hierarchy must be already a number or a unique identifier suitable for comparing using EQL. If hierarchy is a string, it will be interned in the current package
Return logger’s own log level (if set) or the one it had inherited from parent
Return a string with each element of LIST printed separated by SEPARATOR
Prints the *CONFIGURATIONS* list
Very DWIM oriented friendly way of configuring loggers and appenders.
(LOG:CONFIG [LOGGER-IDENTIFIER] OPTION1 OPTION2...)
LOGGER-IDENTIFIER is optional and defaults to the root logger. It can be
one of the following:
- Logger instance ie result of (LOG:CATEGORY) expansion, or any other form
that returns a logger.
- A list of logger categories, basically a shortcut for (LOG:CATEGORY
’(CAT1 CAT2 CAT3)). An error will be given if logger does not exist. If you want
to ensure logger is created, even if it did not exist before, use
(LOG:CONFIG (LOG:CATEGORY ...) ...)
Without any options (LOG:CONFIG) displays current configuration
—————|—————————————————————
Option | Description
—————|—————————————————————
MAIN OPTIONS.
—————|—————————————————————
:INFO | Or any other keyword identifying a log level, which can be
:DEBUG | shortened to its shortest unambiguous prefix, such as :D.
| Changes the logger level to that level.
—————|—————————————————————
:SANE | Removes logger appenders, then arranges for the logging output
| to be always logged to dynamic value of *TERMINAL-IO*
|
| If used with :DAILY then console appender is not added, unless
| :CONSOLE, :THIS-CONSOLE or :TRICKY-CONSOLE is also specified.
|
| The pattern layout added is affected by many of the pattern
| options below.
—————|—————————————————————
APPENDER OPTIONS
—————|—————————————————————
:CONSOLE | Adds CONSOLE-APPENDER to the logger. Console appender logs
| into current console as indicated by *TERMINAL-IO* stream
—————|—————————————————————
:THIS-CONSOLE | Adds THIS-CONSOLE-APPENDER to the logger. It captures the
(or :THIS) | current value of *TERMINAL-IO* by recursively resolving any
| synonym or two-way streams, and continues to log the
| remembered value, even if it goes out dynamic scope.
|
| On any stream errors it will auto-remove itself.
—————|—————————————————————
:TRICKY-CONSOLE| Adds TRICKY-CONSOLE-APPENDER which acts exactly like
(or :TRICKY) | THIS-CONSOLE appender above, but it checks if dynamic value
| of *TERMINAL-IO* resolves to the same stream and ignores the
| log message if it does.
|
| When debugging multi-threaded code from REPL, this results in
| REPL thread logging to REPL, while threads with some other
| value of *TERMINAL-IO* stream will output to both.
|
| As a shortcut, if THIS-CONSOLE is specified and global console
| appender already exists, it will add TRICKY-CONSOLE instead.
—————|—————————————————————
:SANE2 | Shortcut for :SANE :TRICKY (mnemonic two -> multiple threads)
—————|—————————————————————
:STREAM stream| Changes the stream used for above two dedicated stream
| appenders.
—————|—————————————————————
:DAILY FILE | Adds file appender logging to the named file, which will be
| re-opened every day, with old log file renamed to FILE.%Y%m%d.
|
| Removes any other file based appenders from the logger.
|
| FILE can also contain %Y%m%d like pattern, expansion of which
| will determine when new log file would be opened.
—————|—————————————————————
:FILTER level | Makes all appenders added by above keywords drop messages
| below specified level.
—————|—————————————————————
LAYOUT OPTIONS
General note about layout options, if any appender options are specified
the layout options only affect PATTERN-LAYOUT for new appenders created
by LOG:CONFIG command
But if no appender options are specified, but layout options are, LOG:CONFIG
will change the pattern layout on all console based appenders that output
current *TERMINAL-IO*
—————|—————————————————————
:PATTERN | For any new appenders added, specifies the conversion pattern
| for the PATTERN-LAYOUT. If not given, default pattern will be
| used, modified by below options
—————|—————————————————————
:PRETTY | Add {pretty} option to the pattern to force pretty printing
:NOPRETTY | Add {nopretty} option to the pattern to force no pretty printing
| without one of these, global value is in effect
—————|—————————————————————
:TIME/:NOTIME | Include time into default pattern, default is :TIME
—————|—————————————————————
:FILE or | Include file name into default pattern, :FILE2 uses alternate
:FILE2 | position for the file (in front of the package).
:NOFILE | :NOFILE does not show the file
—————|—————————————————————
:THREAD | Include thread name into default pattern, it will be after the
[<n>[<n2>]] | time, in [%t] format. If :THREAD argument is followed by one
| or two numbers, they will be used as min/max field width.
—————|—————————————————————
:NDC | Include NDC context into default pattern, with optional min/max
[<n>[<n2>]] | field width flags. When used together with :THREAD NDC will be
| printed after the thread name, separated by dash, like this
| example: "[threadname-ndc]"; it will not be shown if unbound
|
| Without :THREAD, its shown in its own square brackets, with
| entire construct not shown if unbound.
—————|—————————————————————
:NOPACKAGE | Add {nopackage} option to the pattern (binds orig package at
:PACKAGE | the site of the log statement. PACKAGE binds keyword package,
| so everything is printed with package prefix
—————|—————————————————————
:TWOLINE | Changes pattern layout to print hard newline before actual log
(or :2LINE) | message. Only makes sense with NOPRETTY or when logging into
| files.
|
| Pretty printing does better job at line splitting then forced
| two line layout, with short log statements placed on a single
| line and longer ones wrapping.
—————|—————————————————————
ASSORTED OTHER OPTIONS
—————|—————————————————————
:PROPERTIES | Configure with PROPERTY-CONFIGURATOR by parsing specified
FILE | properties file
—————|—————————————————————
:WATCH | Used with :PROPERTIES, uses watcher thread to check
| properties file modification time, and reloads if it changes
—————|—————————————————————
:IMMEDIATE- | Used with :SANE, :DAILY or :CONSOLE to create new appenders
FLUSH | with :IMMEDIATE-FLUSH T option, which prevents automatic
| startup of hierarchy watcher thread, which is used for
| auto-flushing.
—————|—————————————————————
:NOADDITIVE | Makes logger non-additive (does not propagate to parent)
:OWN | Shortcut for non-additive (usually has appenders on its own)
:ADDITIVE | Sets additive flag back to T.
—————|—————————————————————
:CLEAR | Reset the child in the hierarchy, by unsetting their log level
| and/or removing appenders from them. Without any other flags
| unset the log levels.
|
:LEVELS | Clears the log levels, this is the default
:APPENDERS | Removes any appenders, levels will not be cleared unless
| :LEVELS is also specified
|
:ALL | Normally :CLEAR does not touch non-additive loggers, that is
| the ones that don’t pass messages to parents. This flag forces
| clearing of non-additive loggers
|
| Note that this option does not change the logger being acted
| upon, just its children. See next option
—————|—————————————————————
:REMOVE <num> | Removes specific appender from the logger. Numbers are 1-based,
| and are same ones displayed by LOG:CONFIG without arguments
—————|—————————————————————
:SELF | Configures the LOG4CL logger, which can be used to debug
| Log4CL itself. Normally all other LOG:CONFIG hides the
| it from view.
—————|—————————————————————
:FORCE-ADD | Normally if you specify :CONSOLE :THIS-CONSOLE or
| :TRICKY-CONSOLE without :SANE (which clears out existing
| appenders), an error will be given if there are any standard
| console appenders that already log to *TERMINAL-IO* or :STREAM
| argument.
|
| This is to prevent from creating duplicate output.
|
| Adding :FORCE-ADD flag skips the above check, and allows you
| to add new console appender regardless.
—————|—————————————————————
:BACKUP | Used together with :DAILY, specifies the :BACKUP-NAME-FORMAT,
| see docstring for the DAILY-FILE-APPENDER class.
|
| For example specifying a DAILY <file> :BACKUP NIL will always
| log to statically named FILE without rolling.
|
| Defaults to NIL if FILE contains percent character or
| FILE.%Y%m%d otherwise.
—————|—————————————————————
Examples:
* (LOG:CONFIG :D) – Changes root logger level to debug
* (LOG:CONFIG :SANE) – Drops all console appenders, change level
to INFO, makes all output appear on current console
* (LOG:CONFIG :SANE2) – As above, but copy all other threads output
to current terminal.
* (LOG:CONFIG :PRETTY :THREAD) - changes active console appenders
layout to force pretty printing and add thread info.
* (LOG:CONFIG :NOPRETTY :PACKAGE) - changes layout to force no
pretty printing, and restoring original *PACKAGE* when printing
* (LOG:CONFIG :WARN :CLEAR) – Changes root logger level to warnings,
and unset child logger levels.
* (LOG:CONFIG ’(PACKAGE) :OWN :DEBUG :DAILY "package-log.%Y%m%d")
Configures the logger PACKAGE with debug log level, logging into
the file "package-log.20130510" which will be rolled over daily;
makes logger non-additive so messages will not be propagated to
logger parents. (To see them on console, remove the :OWN flag, or
add :CONSOLE to the command)
Note: in above example if package name is dotted, you need to
specify the split category list, so if your package name is
COM.EXAMPLE.FOO logger categories will be ’(COM EXAMPLE FOO)
Return log-level string for the level
Return logger additivity
Set logger appender additivity. Returns new additivity
Return a list of logger’s ancestors starting from parent and ending wit root logger
Return the list of logger’s own appenders. Please note that by default loggers inherit their parent logger appenders, see EFFECTIVE-APPENDERS
Return LOGGER categories starting from parent logger as a newly consed list of strings
Return a freshly consed list of LOGGER’s direct children
Return a list of LOGGER’s descendants.
NOSELFP if T filters out Log4CL self-logger from descendants
Return source file pathname where logger was instantiated
Return source file pathname where logger was instantiated
Return source file name string where logger was instantiated
Return the logger own log level or NIL if unset. Please note that by default loggers inherit their parent logger log level, see EFFECTIVE-LOG-LEVEL
Set logger log level. Returns logger own log level
Return the name of the logger category itself (without parent loggers)
Translate a more human readable log level into one of the log level constants, by calling LOG-LEVEL-FROM-OBJECT on ARG and current value of *PACKAGE*
Return package categories split as per package configuration
Apply the function to all of logger’s children (but not their descendants)
Apply the function to all of logger’s descendants
Restore logging configuration CONFIGURATION, which can be a name,
a CONFIGURATION instance, or a number indicating Nth (zero
based) configuration in the *CONFIGURATIONS* list. NIL is treated as
zero.
When searching for the
Before restoring the configuration, the current logging configuration
is automatically saved under the name "Autosave <timestamp>", unless
an equivalent configuration is already in the list
If CONFIGURATION is NIL restores first element of *CONFIGURATIONS* that is not equivalent to the current configuration. So successive (RESTORE) will swap last two configurations
Save current logging configuration into configuration list.
NAME – specifies the name of this logging configuration, if NAME is not
specified, one is automatically provided as "Saved on <timestamp>".
If its equivalent to some other configuration, save it only if it had
a different name, otherwise lift the older equivalent configuration to
the top of the list.
When *SAVE-CONFIGURATIONS-TO-FILE* is T (default) the configuration list list will also be saved to a file ".log4cl-configurations.lisp-expr" in user home directory. File name can be customized by changing *CONFIGURATIONS-FILE* variable
Removes all appenders from the logger.
Removes APPENDER from the logger. APPENDER-REMOVED generic function will be called if appender was removed
Removes the watch token from the hierarchy, that matches the specified KEY and TEST arguments, which are passed to REMOVE function. Holds per-hierarchy lock doing its operation
Clear the logging configuration in the current hierarchy, and configure root logger with INFO log level and a simple console appender
Restore logging configuration CONFIGURATION, which can be a name,
a CONFIGURATION instance, or a number indicating Nth (zero
based) configuration in the *CONFIGURATIONS* list. NIL is treated as
zero.
When searching for the
Before restoring the configuration, the current logging configuration
is automatically saved under the name "Autosave <timestamp>", unless
an equivalent configuration is already in the list
If CONFIGURATION is NIL restores first element of *CONFIGURATIONS* that is not equivalent to the current configuration. So successive (RESTORE) will swap last two configurations
Compare two logging configurations and return T if they have exactly same loggers and levels
Save current logging configuration into configuration list.
NAME – specifies the name of this logging configuration, if NAME is not
specified, one is automatically provided as "Saved on <timestamp>".
If its equivalent to some other configuration, save it only if it had
a different name, otherwise lift the older equivalent configuration to
the top of the list.
When *SAVE-CONFIGURATIONS-TO-FILE* is T (default) the configuration list list will also be saved to a file ".log4cl-configurations.lisp-expr" in user home directory. File name can be customized by changing *CONFIGURATIONS-FILE* variable
Set the log level of a logger. Log level is passed to
MAKE-LOG-LEVEL to determine canonical log level. ADJUST-P controls if
logger effective log level needs to be recalculated, the caller should
NIL doing bulk operations that change the level of many loggers, as to
avoid overhead.
Returns if log level had changed as the 1st value and new level as the second value.
Called when appender is added to a logger. Default method is used to keep logger count, and if re-implemented the (CALL-NEXT-METHOD) needs to be called.
stream-appender)) ¶Add appender to the watch tokens in the current hierarchy, unless IMMEDAITE-FLUSH property is set.
Writes the log message into the appender. Text of the log message
is specified indirectly via LOG-FUNC argument, which will be a
function that accepts a stream, and writes the text of log message to
it.
This function should first figure out or obtain the stream to write
the log message to, and then call the LAYOUT-TO-STREAM function to have
layout do actual formatting.
If appender destination is ultimately not a stream, then it can
obtain the full text of the log message by calling LAYOUT-TO-STREAM
inside of WITH-OUTPUT-TO-STRING
Example:
(defmethod appender-do-append ((self custom-appender) logger level log-func)
(let ((stream (custom-appender-destination)))
(layout-to-stream (slot-value self ’layout)
stream logger level log-func))
(values))
Return value of this function is ignored
rolling-file-appender-base) logger level log-func) ¶fixed-stream-appender-base) logger level log-func) ¶stream-appender) logger level log-func) ¶serialized-appender) logger level log-func) ¶tricky-console-appender) logger level log-func) ¶counting-appender) logger level log-func) ¶counting-appender) logger level log-func) ¶Perform any flushes of appender output if needed, marking the that output was performed at time TIME. This function can be called from any thread and should take care of serializing
stream-appender) time) ¶Flush the non-immediate-flush appender unconditionally if there been any output. TIME will be used to mark the time of the flush
Returns the appenders file name
daily-file-appender)) ¶automatically generated reader method
file-appender)) ¶automatically generated reader method
Returns the appenders last backup file name
daily-file-appender)) ¶automatically generated reader method
Returns the appenders next backup file name
daily-file-appender)) ¶automatically generated reader method
Called when appender is removed from a logger
Default method is used to keep logger refcount, and calls
CLOSE-APPENDER when it reaches zero. If re-implemented
the (CALL-NEXT-METHOD) needs to be called
stream-appender)) ¶When appender refcount is zero, remove it from watch tokens
Decrement logger count and call CLOSE-APPENDER if it reaches zero
Should return the stream to which appender will write log messages
console-appender)) ¶Returns current value of *GLOBAL-CONSOLE*, which is a synonym stream for *TERMINAL-IO*
fixed-stream-appender)) ¶automatically generated reader method
fixed-stream-appender-base)) ¶automatically generated reader method
fixed-stream-appender)) ¶automatically generated writer method
fixed-stream-appender-base)) ¶automatically generated writer method
Should move or rename LOG-FILENAME into the
BACKUP-FILENAME. When this function is called, LOG-FILENAME is already
closed.
Implemented as generic function so its possible to write extensions that compress the backup log files automatically, or append to them. One possible extension could be having daily log file and a weekly backup, that is appended to each day
daily-file-appender) log-filename backup-filename) ¶Called when appender refcount reaches zero after
being positive. Should close any streams or files that appender had
opened.
fixed-stream-appender-base)) ¶Configure the logging system from specified source
property-configurator) filespec &key auto-reload) ¶Configures logging from the specified file. If AUTO-RELOAD is non-NIL, then after initial configuration will watch the file for modifications and re-configure when it changes. Note that auto-reload will not be configured if initial configuration signaled a error
property-configurator) (s stream) &key) ¶Configures logging from the specified stream
pattern-layout)) ¶automatically generated reader method
pattern-layout)) ¶pattern-layout)) ¶automatically generated writer method
Is called by RESOLVE-DEFAULT-LOGGER-FORM to try to
determine the enclosing lexical scope name. For example if logging
macro is being expanded while compiling local function BAR inside of a
definition of function FOO, the implementation of this method should
strive to return ’(FOO BAR) if possible.
For CLOS method it is recommended that return value be a generic
function name, followed by optional qualifier, and then followed by
any non-T specializers, with EQL specializers flattened to their
values, for example for the :AROUND method FOO with lambda list
of ((OBJ1 BAR) (OPTION (EQL :BAZ)) OBJ3) should strive to return
’(FOO AROUND BAR BAZ)
Return the enclosing block name suitable for naming a logger
Called when a condition is raised doing writing to
the appender by APPENDER-DO-APPEND call, must return a keyword
indicating action to take.
:DISABLE – Appender is permanently disabled by setting ENABLED slot
to NIL, any farther appends will be ignored.
:RETRY – immediately retry logging the same log message. To prevent
forever loops, only up to three retries will be performed, and if
error persists on the third try, appender will be disabled
:IGNORE – Do nothing. Log message will be lost, but appender will
be used again if more log messages come in.
Any other values are treated as :DISABLE
After calling this function, LOG4CL will update the RETRY-COUNT,
IGNORE-COUNT, LAST-ERROR and LAST-IGNORED-ERROR slots of the appender,
based on the return value.
Default primary method logs the error, and returns :DISABLE
temp-appender) c) ¶Prints the log message to the specified stream. log message can is specified indirectly by LOG-FUNC argument, which is a callable object that accepts a stream and writes log message to it
pattern-layout) stream logger level log-func) ¶Format the log statement with the pattern layout
simple-layout) stream logger level log-func) ¶Format the log message with the simple layout
Should return numeric log level from the user
representation, can be specialized per-package to have custom log
level names. Default implementation converts object to string and
parses "fatal" "debug" and so on. Called by MAKE-LOG-LEVEL
function
Converts human readable log level description in ARG into numeric log level.
Supported values for ARG are:
- Symbol or string which name matches log level, e.g: :debug, :info,
DEBUG, USER1, :err "off"
- 1-character long symbol or string, used as a shortcut. All standard
levels can be uniquely identified by their first
character: (o)ff (f)atal (e)rror (w)arn (i)nfo (d)ebug (t)race (u)nset,
- 1 character digit 1 through 9 identifying user1 through user9 levels.
Should rollover the log file file if needed
daily-file-appender)) ¶Expands FILENAME and BACKUP patterns, and if one of them changed, switches to the new log file
DEPRECIATED. Use PACKAGE-OPTIONS macro instead
Return default values for naming options which are: :CATEGORY-SEPARATOR ":"
DEPRECIATED.
Allows packages to optionally massage logger names in their
namespace. CATEGORIES will be a list of category names from parent
to child, and EXPLICIT-P will be non-NIL if that list was specified as
an explicit list constant in a logging macro.
Should return (values NEW-CATEGORIES [CAT-LIST-INDEXES])
Where NEW-CATEGORIES should be a new list of categories to use instead
of CATEGORIES.
CAT-LIST-INDEXES should be a list of three numbers (FILE-IDX
PACKAGE-START-IDX PACKAGE-END-IDX) which have the following meaning:
* FILE-IDX – index of the category representing file name (zero based)
* PACKAGE-IDX – index of the first and last (exclusive) category representing
the package.
Based on the above indexes, the pattern layout %g (package) and
%F (file name) and %G (everything else) will be able to return correct
values, on matter where in the package or filename are located in the
category hierarchy.
Default method will first find PACKAGE shortest nickname, then split
it according to category-separator naming option, then return the
values like so:
(,@<split package> ,*LOGGER-TRUENAME* ,@CATEGORIES)
Find the PACKAGES shortest name or nickname, and prefix CATEGORIES list with it
Read stream and for each line that is not a comment, call PARSE-LINE function.
property-configurator) stream) ¶Parse the stream and apply changes to logging configuration
property-parser) stream) ¶Wrap errors with line number
property-parser) stream) ¶Is called by all logging macros to figure out the
logger to log into. PACKAGE and ENV are the current value of *PACKAGE*
and the macro environment of the logging macro, and ARGS
are its arguments.
Returns two values, first being either a logger, or a form that when
evaluated will return a logger, and second value being list of
arguments to be passed to the format statement that will log the
message.
When second value returned is NIL, then logging macro will not log any message but will rather expand into a non-NIL value if logging is enabled on that logger.
- When first element of args is NIL or a constant string, calls
RESOLVE-DEFAULT-LOGGER-FORM that will try to obtain logger name from
the environment
- When first argument is a :KEYWORD, returns logger named <KEYWORD>
- When first argument is a quoted symbol, returns logger named
<current-package>.<symbol>
- Otherwise returns the form ‘(GET-LOGGER ,(FIRST ARGS) ,@(REST ARGS))’
Called from SAVE-HOOKS, must close appenders that
own their stream in a such way, so its possible to reopen them
fixed-stream-appender-base)) ¶temp-appender)) ¶automatically generated reader method
temp-appender)) ¶automatically generated writer method
Will be called on each member of WATCH-TOKENS list
when hierarchy watcher thread is started. If a unhandled condition is
signaled from this function the watcher thread will remove
corresponding token from the list
property-configurator-file-watch)) ¶Checks properties file write time, and re-configure from it if it changed. Catches and does not re-signal PROPERTY-PARSER-ERROR, so watching the file continues if newly modified file had an error
stream-appender)) ¶logger) &optional env) ¶Creates the logger when a logger constant is being loaded from a compiled file
configuration) stream) ¶configuration-element) stream) ¶source-file-logger) stream) ¶file-logger) stream) ¶property-configurator-file-watch) stream) ¶file-appender-base) (slot-name (eql stream))) ¶Base class for all LOG4CL errors
program-error.
simple-error.
log4cl-error.
parse-error.
log4cl-error.
parse-error.
common-lisp.
:condition
:line-num
:line
Appender is log message sink, and is responsible
for physically delivering the log message, somewhere. The formatting
of message is done by layout.
Appenders can be called from multiple threads and are responsible for
serializing access to any resources.
Appender will not be appended into if ENABLED slot is NIL
HANDLE-APPENDER-ERROR generic function is called if condition is signaled from APPENDER-DO-APPEND method. See description of that function for the protocol.
appender-do-append.
(setf appender-enabled-p).
appender-enabled-p.
(setf appender-error-count).
appender-error-count.
(setf appender-filter).
appender-filter.
(setf appender-ignored-error-count).
appender-ignored-error-count.
(setf appender-last-error).
appender-last-error.
(setf appender-last-ignored-error).
appender-last-ignored-error.
(setf appender-layout).
appender-layout.
(setf appender-logger-count).
appender-logger-count.
(setf appender-loggers).
appender-loggers.
(setf appender-message-count).
appender-message-count.
property-alist.
(make-instance (quote log4cl-impl:simple-layout))
:layout
(integer 0)
0
t
:filter
(integer 0)
0
(integer 0)
0
(integer 0)
0
Used to remember log levels for a set of loggers
Holds logger and its log level
log4cl-impl::logger
(error "required argument ~s missing" :logger)
:logger
This slot is read-only.
A stream appender that writes messages to *TERMINAL-IO* stream, which must be a synonym stream
Appender that counts Count the number of times APPENDER-DO-APPEND was called, and writes its output to null sink
common-lisp.
0
An appender that writes to the file named by
expanding a pattern. The expansion is done by the same
converter as the %d conversion pattern of the PATTERN-LAYOUT, which is
a subset of patterns supported by strftime POSIX function.
Properties:
NAME-FORMAT
: Expanded with date formatter to get the name of the current log file
BACKUP-NAME-FORMAT
: Expanded with date formatter to get the name of the backup log file
UTC-P
: Should be non-NIL if name and backup patterns expand the UTC time
instead of local. Defaults to NIL.
MAYBE-ROLL-FILE method works as follows. It expands both name and
backup format (if present).
If either of them differs from their previous values, current log file
will be closed, and a new current log file will be opened.
The old log file will be renamed to %NEXT-BACKUP-NAME, which is a
value of the backup format expansion remembered when original log file
was opened. The new value of the backup format expansion is
remembered in the %NEXT-BACKUP-NAME slot.
In below examples it is assumed that current log file was created an
2012-02-21, and the event being logged is the first one on the next
day.
1) Example: NAME-FORMAT is "test.log" and backup is unset, will
always log to the file named test.log
2) Example: NAME-FORMAT is "test.%Y%m%d.log" and
BACKUP-NAME-FORMAT is unset. Will log into the file
test.20120221.log file, on the rollover it will be closed and
test.20120222.file will be opened.
3) Example: NAME-FORMAT is "test.log" and BACKUP-NAME-FORMAT is
"test.%Y%m%d.log". Will log into the file test.log. On rollover
test.log will be renamed to test.20120221.log, and new test.log
will be created.
4) Example: NAME-FORMAT is "test.%Y%m%d" and BACKUP-NAME-FORMAT is "test.log.bak". Will log into the file test.20120210.log and when the day changes, will rename it to test.log.bak (erasing old one if it exists)
:backup-name-format
:name-format
:utc
This slot is read-only.
This slot is read-only.
This slot is read-only.
Appender that writes to a file with a fixed file name
:file
This slot is read-only.
Appender that writes to a file and closes it when its no longer attached to loggers
t
Appender that writes message to the stream in STREAM slot.
common-lisp.
:stream
Abstract layout class
Contains configuration that affects expansion of logger macros.
"."
log4cl-impl:+expr-format-simple+
:use-shortest-nickname
log4cl-impl:+log-level-debug+
Pattern layout uses a configurable conversion pattern to format log
messages. For example, the following patterns produce these log
messages:
"%-5p [%c] - %m%n" produces the message
INFO [CATEGORY.SUBCATEGORY.NAME] - message text
and "%-5p [%c{2}{:invert}{–}] - %m%n" produces the message:
INFO [subcategory–name] - message text
Syntax of conversion pattern is: %[<FLAGS>]<PATTERN-CHAR>[{<EXTRA-ARG>}...]
FLAGS are consists of:
[:][;<PREFIX>;][;<SUFFIX>;][-]<MIN>.<MAX>
If a string resulting from the pattern expansion is longer then MAX
its truncated by omitting characters from the start. Then if its
shorter then MIN its padded with spaces to the right or left (when
preceded by a minus)
If PREFIX and/or SUFFIX is specified, then string is wrapped with them
and all padding for justification, is done before the prefix and after
the suffix. The length of prefix and suffix are not included into
MIN/MAX or/padding calculations.
Example: %-7;<;;>;p with p expanding to INFO, will produce the string
" <INFO>"
If : flag is specified, and string is empty, then no output is made, including
not outputting any prefix or suffix.
Performance considerations: All formatting is done without consing,
except for the case of %m (user message) format, when it has MIN or
MAX field width flags. That is because user message is passed around
as a lambda that writes to the stream, and in order for its length to
be known, (with-output-to-string) is used.
Following pattern characters are recognized:
——————————————————————–
%p Log level string, for example DEBUG, INFO, TRACE.
%P Log level string in lower case
%c Full category name of the logger for example CL-USER:FOO:BAR.
There can be up to three extra flags in curly braces. Extra flag
can be a set of empty curly braces, in this case the effect is same
as default value.
First extra flag is PRECISION. When a single integer its a number
of categories to display, parent categories will be omitted if
logger is more then N levels deep.
For example if logger category name is CL-USER:ONE:TWO:THREE then
conversion pattern %c{2} will produce TWO:THREE
When PRECISION is specified as {<FROM>,<COUNT>}, then it means
categories starting at FROM (zero-based) and output <COUNT>
categories. Negative or zero means until end of the categories.
Example: Category printed for a logger named CL-USER:ONE:TWO:THREE
Precision | Result
———-|—————-
{1} | THREE
{2} | TWO:THREE
{0,1} | CL-USER
{5,1} |
{1,1} | ONE
{1,2} | ONE:TWO
{1,0} | ONE:TWO:THREE
{1,100} | ONE:TWO:THREE
Second extra argument is SEPARATOR and will be a separator used
between category names. If not present then the loggers native
value will be used, which can be overwritten per package by
NAMING-OPTION method
Third extra argument if present, can be one of :UPCASE, :DOWNCASE or
:INVERT and will result in printing of the category name in the
corresponding manner, similar to using non-standard readtable-case
For example when logger category is CL-USER.FOO.BAR outputting it
with conversion pattern of %c{}{–}{:invert} will result print it
as cl-user–foo–bar
——————————————————————–
%g - like to %c, but only portion of the categories that represent
the package name
%C - like to %c, but only portion of the categories that are not
the package name.
Example: assuming category separator setup for the package was a
dot, and a (log:logger :one.two.three) was instantiated in package
cl.dotted.package:
%g => CL.DOTTED.PACKAGE
%g{}{–}{:downcase} => cl–dotted–package
%C => ONE.TWO.THREE
(%C{}{ }{:downcase}) => (one two three)
%F namestring of a file where logger was instantiated, same as
returned by LOGGER-FILE-NAMESTRING
——————————————————————–
%d The date/time of the log message in UTC, extra argument
can be a date pattern. Default date pattern is
%d{%Y-%m-%d %H:%M:%S}
To facilitate testing there can be optional second extra
argument, which could be decimal value that will be used as
universal time instead calling (GET-UNIVERSAL-TIME)
Lisp does not have portable facility to get week and month
names, so date format is printed by PATTERN-LAYOUT-FORMAT-DATE
generic function, default method of which uses hard-coded
English week/month/weekday names.
Valid date format values are same as C strftime function, with
GNU extensions.
%A – Full weekday name
%A – Abbreviated weekday name
%B – Full month name
%b – Abbreviated month name
%c – Standard date and time string
%d – Day of month as a decimal(01-31)
%H – Hour(00-23)
%I – Hour(01-12)
%m – Month as decimal(01-12)
%M – Minute as decimal(00-59)
%p – AM or PM
%P – am or pm
%S – Second as decimal(00-59)
%y – Year in decimal without century(0-99)
%Y – Year including century as decimal
%z – Time zone offset from UTC in -hhmm or +hhmm format
%% – The percent sign
——————————————————————–
%D date-time in local time, extra arguments can contain a strftime pattern
%h hostname of the system (implementation dependent, obtained once
when pattern is parsed, and cached
%t Current thread name
%x Value of *ndc-context* variable from (with-ndc (context)) macro
%i Process id of the lisp process, implementation dependent.
%I Two spaces repeated *log-indent* times. Different padding string
can be specified in an extra argument.
%n Mandatory newline, issues (TERPRI) on the stream. %:n issues (TERPRI) if
*PRINT-PRETTY* is NIL or (PPRINT-NEWLINE :MANDATORY) otherwise
%& Optional newline, issues FRESH-LINE on the stream
%m Actual user log message.
——————————————————————–
PRETTY-PRINTER CONTROL
%< and %> the formatting inside is wrapped into
PPRINT-LOGICAL-BLOCK. Whenever pretty printing is actually used
depends on runtime value of *PRINT-PRETTY* at call site
The opening pattern can have extra arguments, with following
meaning:
%<{pretty}[{<num>}] - bind *PRINT-PRETTY* to T at runtime,if followed
by a number, set *print-right-margin* to it
%<{nopretty} - bind *PRINT-PRETTY* to NIL at runtime
%<{package} - bind *PACKAGE* to :KEYWORD package
%<{nopackage} - bind *PACKAGE* to original package
Both pretty and package can be used together like this %<{pretty}{package} ... %>
%_ conditional newline, issues (PPRINT-NEWLINE :linear)
%:_ conditional newline, issues (PPRINT-NEWLINE :fill)
%[<n>]N does (PPRINT-INDENT :block n).
%:[<n>]N does (PPRINT-INDENT :current n).
%<n1>.<n2>N is similar to above but the second argument of
PPRINT-INDENT is calculated as (+ n1 (* n2 *LOG-INDENT*)).
For example with %5.2N the wrapped lines will be indented
default %I amount, plus extra 5 spaces.
Class that holds configurator state while parsing the properties file
Class for reading Java style property files.
File appender that periodically checks if it needs
to rollover the log file.
Properties:
ROLLOVER-CHECK-PERIOD
: An integer, when current time advances past the boundary evenly divisible by this
number a call to MAYBE-ROLL-FILE will be made to check if log file needs
to be rolled over
Appender that serializes itself using a lock
(bordeaux-threads:make-recursive-lock "log4cl serialized appender lock")
Simple layout outputs log level and user message separated by dash. For example: INFO - user log message
Appender that writes message to stream. Stream is
obtained on each output by calling APPENDER-STREAM function.
Properties:
IMMEDIATE-FLUSH
: When non-NIL will call FINISH-OUTPUT after every log message
FLUSH-INTERVAL
: When set, will only flush if previous flush was earlier than FLUSH-INTERVAL seconds ago. In addition a background thread will be used to flush all appenders with FLUSH-INTERVAL set. See ADD-WATCH-TOKEN
A mixing for STREAM-APPENDER that will remove the appender if it encounters an error matching ERROR-TYPE
(quote error)
:error-type
An appender that captures the current value of *TERMINAL-IO*
stream, and continues logging to it, until it encounters a stream
error, at which point it will delete itself.
To capture the target output stream, any chain of SYNONYM-STREAM or TWO-WAY-STREAM is followed recursively, until result is no longer either synonym or two way stream
common-lisp.
log4cl-impl:*global-console*
Captures the *TERMINAL-IO* stream just like the
THIS-CONSOLE-APPENDER does, but at runtime checks if current value of
*TERMINAL-IO* resolves to the same value and only writes the
message if its different.
When used together with CONSOLE-APPENDER, results that current REPL
thread logs to REPL, while other threads log both to their
*TERMINAL-IO* and REPL.
Auto-deletes itself when encounters stream error
Current line being parsed
Current line number in the input stream
List of all LOGGER-CONFIGURATION objects
Naming configuration for dotted packages
Array of all hierarchies in the system
Global lock for changing logging configuration
Number of hierarchies registered with the log4cl library. Each hierarchy has independent configuration with regards to log levels and appenders
How long hierarchy watcher thread sleeps between calling WATCHER-HOOK of each hierarchy
True when we are inside of user log function, used to distinguish errors that are signaled the log statement itself, vs errors in layout or appender.
Package at call site or NIL if log statement had no literal symbols interned in *PACKAGE*
Value of (GET-UNIVERSAL-TIME) for the current log event
EQL hash table mapping hierarchy identifier to hierarchy index
Universal time of the current watcher heartbeat
The hierarchy watcher thread
Extra bindings for watcher thread
Define a pattern formatter function, with the signature of
(LAMBDA (STREAM FMT-INFO LOGGER LOG-LEVEL LOG-FUNC))
Arguments:
STREAM - stream to print stuff to
FMT-INFO - instance of FORMAT-INFO
LOGGER - the logger category that event came from
LOG-LEVEL - log level of the message
LOG-FUNC - user log function that outputs actual log message
When STOPCHAR is specified, the pattern format will be parsed until
%<STOPCHAR> is encountered, and the formatting function that outputs
everything in between will be passed as the extra argument to the
formatter, making the signature
(LAMBDA (STREAM FMT-INFO LOGGER LOG-LEVEL LOG-FUNC WRAPPED-FORMATTER))
The WRAPPED-FORMATTER will be a function with the same signature as regular
non-wrapped formatter.
This second form allows writing formatters that establish the dynamic context for the pattern inside, for example %< %> formatter that wraps everything inside into PPRINT-LOGICAL-BLOCK is implemented this way.
Set custom options for expansion of logging macros in a specified
package.
PACKAGE - the package options are being set for, defaults to
*PACKAGE*. No references to the package itself will be retained,
instead options are keyed by package name string
CATEGORY-CASE - Determining how logger naming converts symbols to in
the category name.
Valid values are:
- NIL : As printed by PRINC (ie affected by active *READTABLE*)
- :UPCASE : Convert to upper case
- :DOWNCASE : Convert to lower case
- :INVERT : Invert in the same way inverted READTABLE-CASE does it
- :PRESERVE : Do not change
Note that pattern layout offers similar facility that changes how
logger category is printed on the output side.
SHORTEST-NICKNAME - When T (default), the shortest of package name or
any of its nicknames will be used as logger category, otherwise official
package name will be used.
CATEGORY-SEPARATOR - String that separates logging categories,
defaults to dot.
EXPR-PRINT-FORMAT - The FORMAT control string, for two arguments
used to print expressions, first argument is quoted expression form,
and second argument is value. Default is "~W=~W~^ ~:_". If
format string contains ~:> directive (terminate pretty printing block),
then corresponding format argument will be a (NAME VALUE) list
EXPR-LOG-LEVEL - the log level for the (LOG:EXPR) macro. Default
is :DEBUG.
OLD-LOGGING-MACROS - If set, log statements without constant format
string such as (LOG:DEBUG a b c d) will be interpreted as logging to
logger stored in variable A with format string B and more format
arguments, instead of treating them as (LOG:EXPR a b c d)
Run BODY with %PARSE-LINE and %PARSE-LINE-NUM bound to the remembered location, so that any errors signaled will have correct location
Processes the naming configuration options
Recalculate LOGGER mask by finding out which log levels have reachable appenders.
Return a list of (PROPNAME VALUE) extra display properties to print when displaying an appender. Some of the properties are included only conditionally, such as last error or error count
Restores logging configuration
Test if logging configuration name was auto-generated
Calls the user log function, binding *INSIDE-USER-LOG-FUNCTION* for the duration to indicate that any errors must be re-thrown, rather then disable the appender
Parses the pattern format and returns a function with lambda-list of (STREAM LOGGER LOG-LEVEL LOG-FUNC) that when called will output the log message to the stream with the specified format.
Convert STRING according to CASE
First filter all properties through through INSTANCE-PROPERTY-FROM-STRING, and then create the instance
Return the currently active hierarchy
Flushes all existing appenders
Returns a FORM that is used as an expansion of log-nnnnn macros
file.
Helper function to print either %d or %D (date/time) pattern
Write STRING to the STREAM, respecting flags in info
Retrieve or create a logger.
CATEGORIES – List of category names
SEPARATOR – Category separator. Will only be used if logger did not
exist before.
CAT-CASE – How each category case is treated. See NAMING-OPTION
generic function for description
FORCE-STRING-CASE – Whenever elements of category which are strings,
should also undergo case conversion according to CAT-CASE
CREATEP – Create the logger if it does not exist
FILE – pathname, source file being compiled
PKG-IDX-START/PKG-IDX-END – zero based indexes as to where
in CATEGORIES package name starts ends, meaning of indexes
is like SUBSEQ.. If package is unknown, both must be NIL
For historical reason the above indexes are incremented by one before
being stored in FLAGS slot, and functions LOGGER-PKG-IDX-START/END
return them 1 based, with 0 being used as a flag that there is no
package name in the category.
IS-FILE-P – T when its an actual SOURCE-FILE-LOGGER being requested, which is a special type of leaf logger representing the source file.
Return non-NIL if logging with LEVEL will actually reach any appenders
Do one iteration of watcher loop.
Figures out if we should include the debug-name into the stack of
nested blocks.. Should return the symbol to use.
For now SBCL seems to use:
SYMBOL => normal defun block
(LABELS SYMBOL) => inside of labels function
(FLET SYMBOL) => inside of flet function
(LAMBDA (arglist) => inside of anonymous lambda
(SB-PCL::FAST-METHOD SYMBOL ...) for defmethod
(SB-PCL::VARARGS-ENTRY (SB-PCL::FAST-METHOD SYMBOL )) for defmethod with &rest parametwer
(SB-C::HAIRY-ARG-PROCESSOR SYMBOL) => for functions with complex lambda lists
In all of the above cases except LAMBDA we simply return SYMBOL, for
LAMBDA we return the word LAMBDA and NIL for anything else.
Example: As a result of this default logger name for SBCL for the
following form:
(defmethod foo ()
(labels ((bar ()
(funcall (lambda ()
(flet ((baz ()
(log-info "test")))
(baz))))))
(bar)))
will be: package.foo.bar.baz
Starts watcher thread if any existing appenders don’t have :immediate-flush option
Parse boolean value
Returns t if log level is enabled for the logger in the context of the current application.
Try to find the package at log event site. Can return NIL if package does not exist at runtime
Returns the universal time of the current log event
Return lower case log-level string for the level
Submit message to logger appenders, and its parent logger
Return length of logger itself (without parent loggers)
mask.
Implement the parsing for (log:expr) arguments. Should return the list of arguments to FORMAT starting with control string
Different version of loggers load-form, that does not remember the file name. This allows saved logging configuration to be restored, even if loggers had moved to a different file, without overwriting their file with its value when configuration was saved.
Flush the APPENDER’s stream if needed, assumes that output had been just made to an appender. Should be called with the appender lock held
If configurations list empty and *CONFIGURATIONS-FILE* exists in home directory restore configuration list from it
Given universal time TIME return next boundary evenly divisible by CHECK-PERIOD seconds
While next character at START is curly brace, collect anything
between it and a closing curly brace into a string.
For the set of empty curly braces, collects NIL.
Return a list, with first element being new parse position, and rest
being extra arguments collected
Example: For the string {one}{}{three} will return the list (14 "one" NIL "three")
Common helper that handles both .rootLogger= and .logger.name= lines
Utility method to make a list of logging configuration starting from LOGGER. Returns a list of CONFIGURATION-ELEMENT objects
Dereference synonym streams
Save all appenders, that is, clean up all resources.
Save CNF logging configuration into *CONFIGURATIONS* list. If its equivalent to some other configuration, save it only if it had a different name, otherwise lift the older equivalent configuration to the top of the list
Flushes all existing appenders, and stops watcher thread
Return a list naming SBCL lexical environment. For example when compiling local function FOO inside a global function FOOBAR, will return (FOOBAR FOO)
Set logger additivity.
Return the shortest name or nickname of the package
Print logger settings and its children to *STANDARD-OUTPUT*
Example output:
+ROOT, WARN
|
+-#<CONSOLE-APPENDER>
| with #<PATTERN-LAYOUT>
| :pattern [%P] %c %m%n
| :immediate-flush: nil
| :flush-interval: 1
+-LOG4CL
|
+-SELF (non-additive), DEBUG
| | :config (:SANE, :OWN :TWOLINE :D)
| |
| +-#<CONSOLE-APPENDER 0x123123>,
| | with #<PATTERN-LAYOUT>
| | :pattern [%P] %c %m%n
| | :immediate-flush: nil
| | :flush-interval: 1
| +-#<DAILY-ROLLING-APPENDER 0x12345>
| with #<SIMPLE-LAYOUT 1234>
| :immediate-flush NIL
| :flush-interval: 1
|
+-OTHER, DEBUG
file.
Splits the category name into a list of categories from parent to child. Uses NAMING-OPTION to determine category separator
Split the STRING into a list of strings. If SKIP-WHITESPACE-P is non-NIL strip whitespace from the string first
Strip tab and space characters from a string
Trim the list in global variable VAR to at most *MAX-CONFIGURATIONS* elements
Print the log LEVEL’s name to the STREAM
Helper function that writes STRING to STREAM, optionally doing case conversion.
naming-configuration)) ¶automatically generated reader method
naming-configuration)) ¶automatically generated writer method
naming-configuration)) ¶automatically generated reader method
naming-configuration)) ¶automatically generated writer method
naming-configuration)) ¶automatically generated reader method
naming-configuration)) ¶automatically generated writer method
naming-configuration)) ¶automatically generated reader method
naming-configuration)) ¶automatically generated writer method
naming-configuration)) ¶automatically generated reader method
naming-configuration)) ¶automatically generated writer method
naming-configuration)) ¶automatically generated reader method
naming-configuration)) ¶automatically generated writer method
property-parser-error)) ¶property-parser-error)) ¶configuration)) ¶automatically generated reader method
configuration)) ¶automatically generated writer method
property-configurator-file-watch)) ¶automatically generated reader method
property-configurator-file-watch)) ¶automatically generated writer method
format-info)) ¶automatically generated reader method
pattern-category-format-info)) ¶automatically generated reader method
case.
format-info)) ¶automatically generated reader method
format-info)) ¶automatically generated reader method
pattern-date-format-info)) ¶automatically generated reader method
pattern-pretty-fmt-info)) ¶automatically generated reader method
format-info)) ¶automatically generated reader method
format-info)) ¶automatically generated reader method
pattern-pretty-fmt-info)) ¶automatically generated reader method
pattern-category-format-info)) ¶automatically generated reader method
format-info)) ¶automatically generated reader method
pattern-pretty-fmt-info)) ¶automatically generated reader method
format-info)) ¶automatically generated reader method
pattern-category-format-info)) ¶automatically generated reader method
pattern-category-format-info)) ¶automatically generated reader method
format-info)) ¶automatically generated reader method
Prints UNIVERSAL-TIME to the STREAM according to strftime like PATTERN.
pattern-date-format-info)) ¶automatically generated reader method
pattern-date-format-info)) ¶automatically generated reader method
configuration-element)) ¶automatically generated reader method
property-parser-error)) ¶property-parser-error)) ¶property-parser-error)) ¶property-parser-error)) ¶line.
configuration-element)) ¶automatically generated reader method
configuration)) ¶automatically generated reader method
name.
configuration)) ¶automatically generated writer method
name.
Should parse extra arguments after the end of the
conversion character in the PATTERN-STRING and return next parse
position. The START is the index of the first character in the
conversion pattern after the PATTERN-CHAR, ie in the string
%-5p{foobar} it will be at the opening curly brace.
Should return two values, new parse position and either FMT-INFO or its subclass.
(eql #\<)) pattern start) ¶(eql #\i)) pattern start) ¶(eql #\i)) pattern start) ¶(eql #\h)) pattern start) ¶(eql #\d)) pattern start) ¶(eql #\d)) pattern start) ¶(eql #\g)) pattern start) ¶(eql #\g)) pattern start) ¶(eql #\c)) pattern start) ¶(eql #\c)) pattern start) ¶Default method does not parse any extra arguments and returns INFO unchanged
Called to handle properties that start with a
common prefix. KEYWORD will be the 1st token of the property name,
interned as a keyword. MORE-TOKENS are the rest of the name tokens as strings
For example for a the properties stream line:
"log4cl:foo:bar=baz"
this function will be called with the arguments
(:LOG4CL ’("FOO" "BAR") "BAZ"value)
property-configurator) (keyword (eql :appender)) tokens value) ¶property-configurator) (keyword (eql :additivity)) tokens value) ¶property-configurator) (keyword (eql :logger)) tokens value) ¶property-configurator) (keyword (eql :rootlogger)) tokens value) ¶property-configurator) keyword tokens value) ¶Ignores anything that does not start with LOG4CL prefix, otherwise calls PARSE-PROPERTY-TOKENS again (which will convert 2nd level of the token name into the keyword and call this function again
Called for each NAME=VALUE line in the properties stream. Both NAME and VALUE are strings
property-parser) name value) ¶Handles two special cases of SEPARATOR=VALUE and
READ-CASE=VALUE (ignoring case differences), and updates the parser
accordingly, otherwise splits NAME with current separator, converts
tokens according to read case, and forwards to PARSE-PROPERTY-TOKENS
Called by default PARSE-PROPERTY-LINE
method. TOKENS will be the NAME part of the NAME=VALUE line, split
according to NAME-TOKEN-SEPARATOR and their case adjusted by
NAME-TOKEN-READ-CASE
property-parser) tokens value) ¶Interns the first element of TOKENS as a keyword, and forwards to PARSE-PROPERTY-KEYWORD
Should return list of valid object properties, each
element of the list being (INITARG SLOT TYPE) with INITARG being the
keyword, SLOT is the slot name for the property and TYPE one of:
Type | Description
————————|——————————————————
NUMBER or :NUMBER | Integer property, converted by (parse-integer)
————————|——————————————————
BOOLEAN or :BOOLEAN | Boolean, accepts "true" "t" "on" "false"
| "off" "nil" and empty string
————————|——————————————————
STRING or :STRING | Value as-is after the equal sign in NAME = <value>
| Whitespace is not stripped
————————|——————————————————
:STRING-SKIP-WHITESPACE | Value with the leading whitespace removed
Overriding this method to add extra properties is the only thing
needed to allow extra properties in custom appenders/layouts to be
configurable from by property file configurator. See also
PROPERTY-INITARG-FROM-STRING
daily-file-appender)) ¶rolling-file-appender-base)) ¶file-appender)) ¶fixed-stream-appender)) ¶fixed-stream-appender-base)) ¶stream-appender)) ¶pattern-layout)) ¶Called on appenders and layouts to possibly convert
property value from a string into whatever its supposed to be. Default
method will handle numeric, boolean and string properties, by calling
PROPERTY-ALIST function
Generic implementation for numbers, boolean and string properties, that calls PROPERTY-ALIST function to determine what kind of property it is. Signals error if property is not in the list
Is called by RESOLVE-LOGGER-FORM when logging macro arguments do not specify the logger to log into. See RESOLVE-LOGGER-FORM for return values
Returns the logger named after the enclosing lexical environment
simple-condition.
style-warning.
(or null log4cl-impl::source-file-logger)
structure-object.
simple-string
simple-string
fixnum
0
(or null log4cl-impl::logger)
fixnum
0
(or null hash-table)
(simple-array log4cl-impl::logger-state *)
(map-into (make-array log4cl-impl::*hierarchy-max*) (function log4cl-impl::make-logger-state))
Appender that writes message to the stream in STREAM slot
Represents data for a single conversion pattern
character
:conversion-char
This slot is read-only.
fixnum
0
:minlen
This slot is read-only.
(or null fixnum)
:maxlen
This slot is read-only.
boolean
:right-justify
This slot is read-only.
(or null simple-string)
:prefix
This slot is read-only.
(or null simple-string)
:suffix
This slot is read-only.
boolean
:colon-flag
This slot is read-only.
boolean
:at-flag
This slot is read-only.
Extra formatting flags for %c (log category) pattern
:precision
This slot is read-only.
:start
This slot is read-only.
:separator
This slot is read-only.
common-lisp.
:case
This slot is read-only.
Extra formatting flags for %d and %D patterns
:date-format
This slot is read-only.
:universal-time
This slot is read-only.
:utc-p
This slot is read-only.
Extra formatting flags for %h pattern
:hostname
Extra formatting flags for %I (log indent) pattern
:indent-string
Extra formatting flags for %<...%> (pretty print) format
(or null (member :pretty :nopretty))
:pretty
This slot is read-only.
:margin
This slot is read-only.
common-lisp.
(or null (member :package :nopackage))
:package
This slot is read-only.
Caches process-id
:process-id
Remembered line and line number in the input
stream where object appeared, so we can signal errors with that
info
| Jump to: | %
(
A B C D E F G H I J K L M N O P R S T U W |
|---|