The log4cl Reference Manual

This is the log4cl Reference Manual, version 1.1.4, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Feb 15 06:44:25 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 log4cl

Version

1.1.4

Dependencies
  • bordeaux-threads (system).
  • sb-posix (system).
Source

log4cl.asd.

Child Components

3 Modules

Modules are listed depth-first from the system components tree.


3.1 log4cl/src

Source

log4cl.asd.

Parent Component

log4cl (system).

Child Components

3.2 log4cl/appender

Dependency

src (module).

Source

log4cl.asd.

Parent Component

log4cl (system).

Child Components

3.3 log4cl/configuration

Dependencies
Source

log4cl.asd.

Parent Component

log4cl (system).

Child Components

3.4 log4cl/watcher

Dependencies
Source

log4cl.asd.

Parent Component

log4cl (system).

Child Component

watcher.lisp (file).


3.5 log4cl/client-package

Dependencies
Source

log4cl.asd.

Parent Component

log4cl (system).

Child Component

package.lisp (file).


4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


4.1 Lisp


4.1.1 log4cl/log4cl.asd

Source

log4cl.asd.

Parent Component

log4cl (system).

ASDF Systems

log4cl.


4.1.2 log4cl/src/impl-package.lisp

Source

log4cl.asd.

Parent Component

src (module).

Packages

4.1.3 log4cl/src/defs.lisp

Dependency

impl-package.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.4 log4cl/src/naming.lisp

Dependency

defs.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 log4cl/src/naming-sbcl.lisp

Dependency

naming.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface

enclosing-scope-block-name (method).

Internals

4.1.6 log4cl/src/hierarchy-base.lisp

Dependency

naming-sbcl.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.7 log4cl/src/hierarchy.lisp

Dependency

hierarchy-base.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.8 log4cl/src/logger.lisp

Dependency

hierarchy.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.9 log4cl/src/logging-macros.lisp

Dependency

logger.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.10 log4cl/src/self-logger.lisp

Dependency

logging-macros.lisp (file).

Source

log4cl.asd.

Parent Component

src (module).

Public Interface
Internals

*self-log-config* (special variable).


4.1.11 log4cl/appender/layout.lisp

Source

log4cl.asd.

Parent Component

appender (module).

Public Interface
Internals

property-alist (method).


4.1.12 log4cl/appender/simple-layout.lisp

Dependency

layout.lisp (file).

Source

log4cl.asd.

Parent Component

appender (module).

Public Interface
Internals

write-log-level (function).


4.1.13 log4cl/appender/pattern-layout.lisp

Dependency

simple-layout.lisp (file).

Source

log4cl.asd.

Parent Component

appender (module).

Public Interface
Internals

4.1.14 log4cl/appender/appender-base.lisp

Dependency

pattern-layout.lisp (file).

Source

log4cl.asd.

Parent Component

appender (module).

Public Interface
Internals

4.1.15 log4cl/appender/appender.lisp

Dependency

appender-base.lisp (file).

Source

log4cl.asd.

Parent Component

appender (module).

Public Interface
Internals

4.1.16 log4cl/configuration/configurator.lisp

Source

log4cl.asd.

Parent Component

configuration (module).

Public Interface
Internals

4.1.17 log4cl/configuration/property-parser.lisp

Dependency

configurator.lisp (file).

Source

log4cl.asd.

Parent Component

configuration (module).

Public Interface
Internals

4.1.18 log4cl/configuration/property-configurator.lisp

Dependency

property-parser.lisp (file).

Source

log4cl.asd.

Parent Component

configuration (module).

Public Interface
Internals

4.1.19 log4cl/watcher/watcher.lisp

Source

log4cl.asd.

Parent Component

watcher (module).

Public Interface
Internals

4.1.20 log4cl/client-package/package.lisp

Source

log4cl.asd.

Parent Component

client-package (module).

Packages

log.

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 log4cl.package-setup

Source

impl-package.lisp.

Use List

common-lisp.


5.2 log

Source

package.lisp.

Public Interface

5.3 log4cl-impl

Source

impl-package.lisp.

Nickname

log4cl

Use List

common-lisp.

Public Interface
Internals

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


6.1 Public Interface


6.1.1 Constants

Constant: +log-level-debu1+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu2+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu3+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu4+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu5+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu6+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu7+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu8+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debu9+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-debug+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-error+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-fatal+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-info+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-off+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-trace+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-unset+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +log-level-warn+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +max-log-level+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +min-log-level+
Package

log4cl-impl.

Source

defs.lisp.


6.1.2 Special variables

Special Variable: *configurations-file*

The file where configurations will be saved. Is merged with result of USER-HOMEDIR-PATHNAME

Package

log4cl-impl.

Source

configurator.lisp.

Special Variable: *default-naming-configuration*

Default naming configuration

Package

log4cl-impl.

Source

naming.lisp.

Special Variable: *hierarchy*

Active hierarchy index. All logging functions use logger state indexed by this variable. Can be assigned directly or

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *log-indent*

Indent level can be used to indent logging info, is printed by %I pattern format

Package

log4cl-impl.

Source

defs.lisp.

Special Variable: *logger-truename*

Will be used instead of *COMPILE-FILE-TRUENAME* or *LOAD-TRUENAME* when non-NIL to determine logger’s parent file logger.

Package

log4cl-impl.

Source

defs.lisp.

Special Variable: *max-configurations*

Maximum number of configurations in *CONFIGURATIONS* list

Package

log4cl-impl.

Source

configurator.lisp.

Special Variable: *naming-configuration*

Naming configuration currently in effect

Package

log4cl-impl.

Source

naming.lisp.

Special Variable: *ndc-context*

Value that is printed by %x pattern format

Package

log4cl-impl.

Source

defs.lisp.

Special Variable: *root-logger*

The one and only root logger

Package

log4cl-impl.

Source

logger.lisp.

Special Variable: *save-configurations-to-file*

When non-NIL SAVE will also write configurations to a *CONFIGURATIONS-FILE*

Package

log4cl-impl.

Source

configurator.lisp.

Special Variable: +expr-format-fancy+
Package

log4cl-impl.

Source

naming.lisp.

Special Variable: +expr-format-simple+
Package

log4cl-impl.

Source

naming.lisp.

Special Variable: +self-logger+
Package

log4cl-impl.

Source

self-logger.lisp.

Special Variable: +self-meta-logger+
Package

log4cl-impl.

Source

self-logger.lisp.


6.1.3 Macros

Macro: category (&optional arg)
Package

log.

Alias for

make-logger.

Macro: d (&rest args)

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.

Package

log.

Alias for

log-debug.

Macro: d1 (&rest args)

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.

Package

log.

Alias for

log-debu1.

Macro: d2 (&rest args)

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.

Package

log.

Alias for

log-debu2.

Macro: d3 (&rest args)

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.

Package

log.

Alias for

log-debu3.

Macro: d4 (&rest args)

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.

Package

log.

Alias for

log-debu4.

Macro: d5 (&rest args)

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.

Package

log.

Alias for

log-debu5.

Macro: d6 (&rest args)

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.

Package

log.

Alias for

log-debu6.

Macro: d7 (&rest args)

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.

Package

log.

Alias for

log-debu7.

Macro: d8 (&rest args)

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.

Package

log.

Alias for

log-debu8.

Macro: d9 (&rest args)

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.

Package

log.

Alias for

log-debu9.

Macro: debu1 (&rest args)

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.

Package

log.

Alias for

log-debu1.

Macro: debu2 (&rest args)

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.

Package

log.

Alias for

log-debu2.

Macro: debu3 (&rest args)

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.

Package

log.

Alias for

log-debu3.

Macro: debu4 (&rest args)

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.

Package

log.

Alias for

log-debu4.

Macro: debu5 (&rest args)

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.

Package

log.

Alias for

log-debu5.

Macro: debu6 (&rest args)

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.

Package

log.

Alias for

log-debu6.

Macro: debu7 (&rest args)

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.

Package

log.

Alias for

log-debu7.

Macro: debu8 (&rest args)

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.

Package

log.

Alias for

log-debu8.

Macro: debu9 (&rest args)

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.

Package

log.

Alias for

log-debu9.

Macro: debug (&rest args)

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.

Package

log.

Alias for

log-debug.

Macro: e (&rest args)

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)

Package

log.

Alias for

log-sexp.

Macro: error (&rest args)

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.

Package

log.

Alias for

log-error.

Macro: expr (&rest args)

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)

Package

log.

Alias for

log-sexp.

Macro: f (&rest args)

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.

Package

log.

Alias for

log-fatal.

Macro: fatal (&rest args)

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.

Package

log.

Alias for

log-fatal.

Macro: i (&rest args)

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.

Package

log.

Alias for

log-info.

Macro: in-hierarchy (&rest args)
Package

log.

Source

package.lisp.

Macro: in-log-hierarchy (&optional hierarchy)

Sets the *CURRENT-HIERARCHY* to specified hierarchy, or the default one when NIL

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: in-package-hierarchy (&rest args)
Package

log.

Source

package.lisp.

Macro: in-package-log-hierarchy ()

Sets the *CURRENT-HIERARCHY* to specified hierarchy, or the default one when NIL

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: info (&rest args)

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.

Package

log.

Alias for

log-info.

Macro: log-debu1 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu2 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu3 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu4 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu5 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu6 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu7 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu8 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debu9 (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-debug (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-error (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-fatal (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-info (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu1 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu2 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu3 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu4 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu5 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu6 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu7 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu8 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debu9 (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-debug (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-error (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-fatal (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-info (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-trace (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-warn (&rest args)

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)

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-sexp-with-level (level &rest sexps)

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

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-trace (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: log-warn (&rest args)

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.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: make (&rest args)
Package

log.

Source

package.lisp.

Macro: make-logger (&optional arg)
Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: s (&rest args)

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)

Package

log.

Alias for

log-sexp.

Macro: sexp (&rest args)

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)

Package

log.

Alias for

log-sexp.

Macro: sexp-debu1 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu2 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu3 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu4 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu5 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu6 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu7 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu8 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debu9 (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-debug (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-error (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-fatal (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-info (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-trace (&rest args)
Package

log.

Source

package.lisp.

Macro: sexp-warn (&rest args)
Package

log.

Source

package.lisp.

Macro: t (&rest args)

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.

Package

log.

Alias for

log-trace.

Macro: trace (&rest args)

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.

Package

log.

Alias for

log-trace.

Macro: w (&rest args)

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.

Package

log.

Alias for

log-warn.

Macro: warn (&rest args)

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.

Package

log.

Alias for

log-warn.

Macro: with-hierarchy (&rest args)
Package

log.

Source

package.lisp.

Macro: with-indent ((&optional indent) &body body)

Executes forms in BODY with *LOG-INDENT* set to INDENT

Package

log.

Alias for

with-log-indent.

Macro: with-log-hierarchy ((hierarchy) &body body)

Binds the *CURRENT-HIERARCHY* to the specified hierarchy for the dynamic scope of BODY. HIERARCHY can be hierarchy index or name

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: with-log-indent ((&optional indent) &body body)

Executes forms in BODY with *LOG-INDENT* set to INDENT

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: with-ndc ((&optional ndc) &body body)

Execute forms in BODY with *NDC-CONTEXT* set to CONTEXT. The context is printed by the %x pattern layout format

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: with-ndc-context (&rest args)
Package

log4cl-impl.

Source

package.lisp.

Macro: with-package-hierarchy (&rest args)
Package

log.

Source

package.lisp.

Macro: with-package-log-hierarchy (&body body)

Binds the *CURRENT-HIERARCHY* to the unique hierarchy for the current package for the dynamic scope of BODY.

Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: with-package-naming-configuration ((package) &body body)
Package

log4cl-impl.

Source

naming.lisp.


6.1.4 Ordinary functions

Function: %get-logger (categories cat-sep cat-case &optional force-string-case createp file pkg-idx-start pkg-idx-end is-file-p)

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.

Package

log4cl-impl.

Source

logger.lisp.

Function: add-appender (logger appender)

Adds appender to the logger

Package

log4cl-impl.

Source

logger.lisp.

Function: add-watch-token (token &key test key hierarchy)

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

Package

log4cl-impl.

Source

hierarchy.lisp.

Function: all-appenders (&optional all-hierarchies)

Return all existing appenders in all hierarchies

Package

log4cl-impl.

Source

watcher.lisp.

Function: all-configurations ()

Returns the *CONFIGURATIONS* list

Package

log4cl-impl.

Source

configurator.lisp.

Function: c (&rest args)

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)

Package

log.

Alias for

log-config.

Function: category-case (&optional nc)
Package

log4cl-impl.

Source

naming.lisp.

Function: category-separator (&optional nc)
Package

log4cl-impl.

Source

naming.lisp.

Function: clear-logging-configuration ()

Delete all loggers configuration, leaving only LOG4CL-IMPL

Package

log4cl-impl.

Source

configurator.lisp.

Function: config (&rest args)

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)

Package

log.

Alias for

log-config.

Function: effective-appenders (logger)

Return the list of all appenders that logger output could possible go to, including inherited one

Package

log4cl-impl.

Source

logger.lisp.

Function: effective-log-level (logger)

Return logger’s own log level (if set) or the one it had inherited from parent

Package

log4cl-impl.

Source

logger.lisp.

Function: expr-print-format (&optional nc)
Package

log4cl-impl.

Source

naming.lisp.

Function: fix-method-spec-list (spec)

Flatten method specializer list, remove any T specializers, replace all constant EQL specializers with their values, and eliminate non-constant ones

Package

log4cl-impl.

Source

naming.lisp.

Function: flush-all-appenders (&optional all-hierarchies)

Flush any appenders that had output since being flushed

Package

log4cl-impl.

Source

appender.lisp.

Function: flush-appender (appender &optional time)

Immediately flush the appender output if necessary, marking the time of the flush with TIME

Package

log4cl-impl.

Source

appender.lisp.

Function: hierarchy-index (hierarchy)

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

Package

log4cl-impl.

Source

hierarchy.lisp.

Function: inherited-log-level (logger)

Return logger’s own log level (if set) or the one it had inherited from parent

Package

log4cl-impl.

Source

logger.lisp.

Function: join-categories (separator list)

Return a string with each element of LIST printed separated by SEPARATOR

Package

log4cl-impl.

Source

naming.lisp.

Function: list-configurations (&optional stream)

Prints the *CONFIGURATIONS* list

Package

log4cl-impl.

Source

configurator.lisp.

Function: log-config (&rest args)

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)

Package

log4cl-impl.

Source

configurator.lisp.

Function: log-level-to-string (level)

Return log-level string for the level

Package

log4cl-impl.

Source

logger.lisp.

Function: log4cl-error (message &rest args)
Package

log4cl-impl.

Source

defs.lisp.

Function: logger-additivity (logger)

Return logger additivity

Package

log4cl-impl.

Source

logger.lisp.

Function: (setf logger-additivity) (logger)

Set logger appender additivity. Returns new additivity

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-ancestors (logger)

Return a list of logger’s ancestors starting from parent and ending wit root logger

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-appenders (logger)

Return the list of logger’s own appenders. Please note that by default loggers inherit their parent logger appenders, see EFFECTIVE-APPENDERS

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-categories (logger)

Return LOGGER categories starting from parent logger as a newly consed list of strings

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-category (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-children (logger)

Return a freshly consed list of LOGGER’s direct children

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-depth (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-descendants (logger &optional noselfp)

Return a list of LOGGER’s descendants.

NOSELFP if T filters out Log4CL self-logger from descendants

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-file (logger)

Return source file pathname where logger was instantiated

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-file-logger (logger)

Return source file pathname where logger was instantiated

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-file-namestring (logger)

Return source file name string where logger was instantiated

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-log-level (logger)

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

Package

log4cl-impl.

Source

logger.lisp.

Function: (setf logger-log-level) (logger)

Set logger log level. Returns logger own log level

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-name (logger)

Return the name of the logger category itself (without parent loggers)

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-parent (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: make-log-level (arg)

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*

Package

log4cl-impl.

Source

logger.lisp.

Function: make-package-categories (package)

Return package categories split as per package configuration

Package

log4cl-impl.

Source

naming.lisp.

Function: map-logger-children (function logger)

Apply the function to all of logger’s children (but not their descendants)

Package

log4cl-impl.

Source

logger.lisp.

Function: map-logger-descendants (function logger)

Apply the function to all of logger’s descendants

Package

log4cl-impl.

Source

logger.lisp.

Function: old-logging-macros (&optional nc)
Package

log4cl-impl.

Source

naming.lisp.

Function: pattern-layout-error (message &rest args)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: pop (&optional configuration from-end)

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

Package

log.

Alias for

restore.

Function: push (&optional name)

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

Package

log.

Alias for

save.

Function: remove-all-appenders (logger)

Removes all appenders from the logger.

Package

log4cl-impl.

Source

logger.lisp.

Function: remove-appender (logger appender)

Removes APPENDER from the logger. APPENDER-REMOVED generic function will be called if appender was removed

Package

log4cl-impl.

Source

logger.lisp.

Function: remove-watch-token (token &key test key hierarchy)

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

Package

log4cl-impl.

Source

hierarchy.lisp.

Function: reset-logging-configuration ()

Clear the logging configuration in the current hierarchy, and configure root logger with INFO log level and a simple console appender

Package

log4cl-impl.

Source

configurator.lisp.

Function: restore (&optional configuration from-end)

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

Package

log4cl-impl.

Source

configurator.lisp.

Function: same-configuration-p (c1 c2)

Compare two logging configurations and return T if they have exactly same loggers and levels

Package

log4cl-impl.

Source

configurator.lisp.

Function: save (&optional name)

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

Package

log4cl-impl.

Source

configurator.lisp.

Function: set-log-level (logger level &optional adjust-p)

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.

Package

log4cl-impl.

Source

logger.lisp.

Function: start-hierarchy-watcher-thread ()
Package

log4cl-impl.

Source

watcher.lisp.

Function: stop-hierarchy-watcher-thread ()
Package

log4cl-impl.

Source

watcher.lisp.


6.1.5 Generic functions

Generic Function: appender-added (logger appender)

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.

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: appender-added :after (logger (appender stream-appender))

Add appender to the watch tokens in the current hierarchy, unless IMMEDAITE-FLUSH property is set.

Source

appender.lisp.

Method: appender-added (logger appender)
Source

logger.lisp.

Generic Function: appender-do-append (appender logger level log-func)

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

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: appender-do-append :before ((this rolling-file-appender-base) logger level log-func)
Source

appender.lisp.

Method: appender-do-append ((this fixed-stream-appender-base) logger level log-func)
Source

appender.lisp.

Method: appender-do-append ((this stream-appender) logger level log-func)
Source

appender.lisp.

Method: appender-do-append :around ((this serialized-appender) logger level log-func)
Source

appender.lisp.

Method: appender-do-append :around ((this tricky-console-appender) logger level log-func)
Source

appender.lisp.

Method: appender-do-append ((appender counting-appender) logger level log-func)
Source

appender.lisp.

Method: appender-do-append :before ((appender counting-appender) logger level log-func)
Source

appender.lisp.

Method: appender-do-append :around ((appender appender) logger level log-func)
Generic Function: appender-do-flush (appender time)

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

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: appender-do-flush ((appender 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

Source

appender.lisp.

Method: appender-do-flush (appender time)
Generic Reader: appender-enabled-p (object)
Package

log4cl-impl.

Methods
Reader Method: appender-enabled-p ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

enabled.

Generic Writer: (setf appender-enabled-p) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-enabled-p) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

enabled.

Generic Reader: appender-error-count (object)
Package

log4cl-impl.

Methods
Reader Method: appender-error-count ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

error-count.

Generic Writer: (setf appender-error-count) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-error-count) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

error-count.

Generic Reader: appender-filename (appender)

Returns the appenders file name

Package

log4cl-impl.

Source

appender.lisp.

Methods
Reader Method: appender-filename ((daily-file-appender daily-file-appender))

automatically generated reader method

Target Slot

%current-file-name.

Reader Method: appender-filename ((file-appender file-appender))

automatically generated reader method

Target Slot

filename.

Generic Reader: appender-ignored-error-count (object)
Package

log4cl-impl.

Methods
Reader Method: appender-ignored-error-count ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

ignored-error-count.

Generic Writer: (setf appender-ignored-error-count) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-ignored-error-count) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

ignored-error-count.

Generic Reader: appender-last-backup-file (appender)

Returns the appenders last backup file name

Package

log4cl-impl.

Source

appender.lisp.

Methods
Reader Method: appender-last-backup-file ((daily-file-appender daily-file-appender))

automatically generated reader method

Target Slot

%last-backup-name.

Generic Reader: appender-last-error (object)
Package

log4cl-impl.

Methods
Reader Method: appender-last-error ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

last-error.

Generic Writer: (setf appender-last-error) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-last-error) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

last-error.

Generic Reader: appender-last-ignored-error (object)
Package

log4cl-impl.

Methods
Reader Method: appender-last-ignored-error ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

last-ignored-error.

Generic Writer: (setf appender-last-ignored-error) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-last-ignored-error) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

last-ignored-error.

Generic Reader: appender-layout (object)
Package

log4cl-impl.

Methods
Reader Method: appender-layout ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

layout.

Generic Writer: (setf appender-layout) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-layout) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

layout.

Generic Reader: appender-logger-count (object)
Package

log4cl-impl.

Methods
Reader Method: appender-logger-count ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

logger-count.

Generic Writer: (setf appender-logger-count) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-logger-count) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

logger-count.

Generic Reader: appender-loggers (object)
Package

log4cl-impl.

Methods
Reader Method: appender-loggers ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

loggers.

Generic Writer: (setf appender-loggers) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-loggers) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

loggers.

Generic Reader: appender-message-count (object)
Package

log4cl-impl.

Methods
Reader Method: appender-message-count ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

message-count.

Generic Writer: (setf appender-message-count) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-message-count) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

message-count.

Generic Reader: appender-next-backup-file (appender)

Returns the appenders next backup file name

Package

log4cl-impl.

Source

appender.lisp.

Methods
Reader Method: appender-next-backup-file ((daily-file-appender daily-file-appender))

automatically generated reader method

Target Slot

%next-backup-name.

Generic Function: appender-removed (logger appender)

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

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: appender-removed :after (logger (appender stream-appender))

When appender refcount is zero, remove it from watch tokens

Source

appender.lisp.

Method: appender-removed (logger appender)

Decrement logger count and call CLOSE-APPENDER if it reaches zero

Source

logger.lisp.

Generic Function: appender-stream (appender)

Should return the stream to which appender will write log messages

Package

log4cl-impl.

Source

appender.lisp.

Methods
Method: appender-stream ((this console-appender))

Returns current value of *GLOBAL-CONSOLE*, which is a synonym stream for *TERMINAL-IO*

Reader Method: appender-stream ((fixed-stream-appender fixed-stream-appender))

automatically generated reader method

Target Slot

stream.

Reader Method: appender-stream ((fixed-stream-appender-base fixed-stream-appender-base))

automatically generated reader method

Target Slot

stream.

Generic Writer: (setf appender-stream) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-stream) ((fixed-stream-appender fixed-stream-appender))

automatically generated writer method

Source

appender.lisp.

Target Slot

stream.

Writer Method: (setf appender-stream) ((fixed-stream-appender-base fixed-stream-appender-base))

automatically generated writer method

Source

appender.lisp.

Target Slot

stream.

Generic Function: backup-log-file (appender log-filename backup-filename)

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

Package

log4cl-impl.

Source

appender.lisp.

Methods
Method: backup-log-file (appender log-filename backup-filename)
Method: backup-log-file ((appender daily-file-appender) log-filename backup-filename)
Generic Function: close-appender (appender)

Called when appender refcount reaches zero after
being positive. Should close any streams or files that appender had opened.

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: close-appender ((appender fixed-stream-appender-base))
Source

appender.lisp.

Method: close-appender (appender)
Source

appender.lisp.

Generic Function: configure (configurator source &key auto-reload &allow-other-keys)

Configure the logging system from specified source

Package

log4cl-impl.

Source

property-configurator.lisp.

Methods
Method: configure ((configurator 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

Method: configure ((configurator property-configurator) (s stream) &key)

Configures logging from the specified stream

Generic Reader: conversion-pattern (object)
Package

log4cl-impl.

Methods
Reader Method: conversion-pattern ((pattern-layout pattern-layout))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

%pattern.

Generic Function: (setf conversion-pattern) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf conversion-pattern) :after ((layout pattern-layout))
Source

pattern-layout.lisp.

Target Slot

%pattern.

Method: (setf conversion-pattern) ((pattern-layout pattern-layout))

automatically generated writer method

Source

pattern-layout.lisp.

Generic Function: enclosing-scope-block-name (package env)

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)

Package

log4cl-impl.

Source

naming.lisp.

Methods
Method: enclosing-scope-block-name (package env)

Return the enclosing block name suitable for naming a logger

Source

naming-sbcl.lisp.

Generic Function: handle-appender-error (appender condition)

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

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: handle-appender-error ((a temp-appender) c)
Source

appender.lisp.

Method: handle-appender-error (appender condition)
Source

appender.lisp.

Generic Function: layout-to-stream (layout stream logger level log-func)

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

Package

log4cl-impl.

Source

layout.lisp.

Methods
Method: layout-to-stream ((layout pattern-layout) stream logger level log-func)

Format the log statement with the pattern layout

Source

pattern-layout.lisp.

Method: layout-to-stream ((layout simple-layout) stream logger level log-func)

Format the log message with the simple layout

Source

simple-layout.lisp.

Generic Function: log-level-from-object (obj package)

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

Package

log4cl-impl.

Source

naming.lisp.

Methods
Method: log-level-from-object (arg package)

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.

Generic Function: maybe-roll-file (appender)

Should rollover the log file file if needed

Package

log4cl-impl.

Source

appender.lisp.

Methods
Method: maybe-roll-file ((appender daily-file-appender))

Expands FILENAME and BACKUP patterns, and if one of them changed, switches to the new log file

Generic Function: naming-option (package option)

DEPRECIATED. Use PACKAGE-OPTIONS macro instead

Package

log4cl-impl.

Source

naming.lisp.

Methods
Method: naming-option (package option)

Return default values for naming options which are: :CATEGORY-SEPARATOR ":"

Generic Function: package-wrapper (package categories explicit-p)

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)

Package

log4cl-impl.

Source

naming.lisp.

Methods
Method: package-wrapper (package categories explicit-p)

Find the PACKAGES shortest name or nickname, and prefix CATEGORIES list with it

Generic Function: parse-property-stream (parser stream)

Read stream and for each line that is not a comment, call PARSE-LINE function.

Package

log4cl-impl.

Source

property-parser.lisp.

Methods
Method: parse-property-stream :after ((configurator property-configurator) stream)

Parse the stream and apply changes to logging configuration

Source

property-configurator.lisp.

Method: parse-property-stream :around ((parser property-parser) stream)

Wrap errors with line number

Method: parse-property-stream ((parser property-parser) stream)
Generic Function: resolve-logger-form (package env args)

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.

Package

log4cl-impl.

Source

naming.lisp.

Methods
Method: resolve-logger-form (package env args)

- 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))’

Generic Function: save-appender (appender)

Called from SAVE-HOOKS, must close appenders that
own their stream in a such way, so its possible to reopen them

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: save-appender ((appender fixed-stream-appender-base))
Source

appender.lisp.

Method: save-appender (appender)
Source

appender.lisp.

Generic Reader: temp-appender-error-type (object)
Package

log4cl-impl.

Methods
Reader Method: temp-appender-error-type ((temp-appender temp-appender))

automatically generated reader method

Source

appender.lisp.

Target Slot

error-type.

Generic Writer: (setf temp-appender-error-type) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf temp-appender-error-type) ((temp-appender temp-appender))

automatically generated writer method

Source

appender.lisp.

Target Slot

error-type.

Generic Function: watch-token-check (token)

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

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Methods
Method: watch-token-check ((token 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

Source

property-configurator.lisp.

Method: watch-token-check ((appender stream-appender))
Source

appender.lisp.


6.1.6 Standalone methods

Method: make-load-form ((logger logger) &optional env)

Creates the logger when a logger constant is being loaded from a compiled file

Source

logger.lisp.

Method: print-object ((cnf configuration) stream)
Source

configurator.lisp.

Method: print-object ((elem configuration-element) stream)
Source

configurator.lisp.

Method: print-object ((object source-file-logger) stream)
Source

logger.lisp.

Method: print-object ((object file-logger) stream)
Source

logger.lisp.

Method: print-object ((watch property-configurator-file-watch) stream)
Source

property-configurator.lisp.

Method: print-object ((object logger) stream)
Source

logger.lisp.

Method: shared-initialize :after ((parser property-parser) slots &rest initargs &key &allow-other-keys)
Source

property-parser.lisp.

Method: shared-initialize :after ((config property-configurator) slots &rest initargs &key)
Source

property-configurator.lisp.

Method: shared-initialize :after ((instance this-console-appender) slot-names &key &allow-other-keys)
Source

appender.lisp.

Method: shared-initialize :after ((layout pattern-layout) slots &key conversion-pattern)
Source

pattern-layout.lisp.

Method: slot-unbound (class (appender file-appender-base) (slot-name (eql stream)))
Source

appender.lisp.


6.1.7 Conditions

Condition: log4cl-error

Base class for all LOG4CL errors

Package

log4cl-impl.

Source

defs.lisp.

Direct superclasses
  • program-error.
  • simple-error.
Direct subclasses
Condition: pattern-layout-error
Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses
Condition: property-parser-error
Package

log4cl-impl.

Source

property-parser.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: condition
Package

common-lisp.

Initargs

:condition

Readers

condition-of.

Writers

(setf condition-of).

Slot: line-num
Initargs

:line-num

Readers

line-num-of.

Writers

(setf line-num-of).

Slot: line
Initargs

:line

Readers

line-of.

Writers

(setf line-of).


6.1.8 Classes

Class: appender

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.

Package

log4cl-impl.

Source

appender-base.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: layout
Initform

(make-instance (quote log4cl-impl:simple-layout))

Initargs

:layout

Readers

appender-layout.

Writers

(setf appender-layout).

Slot: logger-count
Type

(integer 0)

Initform

0

Readers

appender-logger-count.

Writers

(setf appender-logger-count).

Slot: loggers
Readers

appender-loggers.

Writers

(setf appender-loggers).

Slot: enabled
Initform

t

Readers

appender-enabled-p.

Writers

(setf appender-enabled-p).

Slot: filter
Initargs

:filter

Readers

appender-filter.

Writers

(setf appender-filter).

Slot: last-error
Readers

appender-last-error.

Writers

(setf appender-last-error).

Slot: last-ignored-error
Readers

appender-last-ignored-error.

Writers

(setf appender-last-ignored-error).

Slot: error-count
Type

(integer 0)

Initform

0

Readers

appender-error-count.

Writers

(setf appender-error-count).

Slot: ignored-error-count
Type

(integer 0)

Initform

0

Readers

appender-ignored-error-count.

Writers

(setf appender-ignored-error-count).

Slot: message-count
Type

(integer 0)

Initform

0

Readers

appender-message-count.

Writers

(setf appender-message-count).

Class: configuration

Used to remember log levels for a set of loggers

Package

log4cl-impl.

Source

configurator.lisp.

Direct methods
Direct slots
Slot: name
Type

atom

Initform

(error "required argument ~s missing" :name)

Initargs

:name

Readers

name-of.

Writers

(setf name-of).

Slot: elements
Initform

(log4cl-impl::remember-logging-configuration)

Initargs

:elements

Readers

elements-of.

Writers

(setf elements-of).

Class: configuration-element

Holds logger and its log level

Package

log4cl-impl.

Source

configurator.lisp.

Direct methods
Direct slots
Slot: logger
Type

log4cl-impl::logger

Initform

(error "required argument ~s missing" :logger)

Initargs

:logger

Readers

logger-of.

Writers

This slot is read-only.

Slot: level
Type

keyword

Initform

(error "required argument ~s missing" :level)

Initargs

:level

Readers

level-of.

Writers

This slot is read-only.

Class: console-appender

A stream appender that writes messages to *TERMINAL-IO* stream, which must be a synonym stream

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

stream-appender.

Direct methods

appender-stream.

Class: counting-appender

Appender that counts Count the number of times APPENDER-DO-APPEND was called, and writes its output to null sink

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

appender.

Direct methods
Direct slots
Slot: count
Package

common-lisp.

Initform

0

Class: daily-file-appender

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)

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

rolling-file-appender-base.

Direct methods
Direct slots
Slot: backup-name-format
Initargs

:backup-name-format

Slot: name-format
Initargs

:name-format

Slot: utc-p
Initargs

:utc

Slot: %current-file-name
Readers

appender-filename.

Writers

This slot is read-only.

Slot: %next-backup-name
Readers

appender-next-backup-file.

Writers

This slot is read-only.

Slot: %last-backup-name
Readers

appender-last-backup-file.

Writers

This slot is read-only.

Class: file-appender

Appender that writes to a file with a fixed file name

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

file-appender-base.

Direct methods
Direct slots
Slot: filename
Initargs

:file

Readers

appender-filename.

Writers

This slot is read-only.

Class: file-appender-base

Appender that writes to a file and closes it when its no longer attached to loggers

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

fixed-stream-appender-base.

Direct subclasses
Direct methods

slot-unbound.

Direct slots
Slot: stream-owner
Initform

t

Class: fixed-stream-appender

Appender that writes message to the stream in STREAM slot.

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

fixed-stream-appender-base.

Direct subclasses

this-console-appender.

Direct methods
Direct slots
Slot: stream
Package

common-lisp.

Initargs

:stream

Readers

appender-stream.

Writers

(setf appender-stream).

Class: layout

Abstract layout class

Package

log4cl-impl.

Source

layout.lisp.

Direct subclasses
Direct methods

property-alist.

Class: naming-configuration

Contains configuration that affects expansion of logger macros.

Package

log4cl-impl.

Source

naming.lisp.

Direct methods
Direct slots
Slot: category-separator
Initform

"."

Readers

%category-separator.

Writers

(setf %category-separator).

Slot: category-case
Readers

%category-case.

Writers

(setf %category-case).

Slot: expr-print-format
Initform

log4cl-impl:+expr-format-simple+

Readers

%expr-print-format.

Writers

(setf %expr-print-format).

Slot: use-shortest-nickname
Initargs

:use-shortest-nickname

Readers

%use-shortest-nickname.

Writers

(setf %use-shortest-nickname).

Slot: expr-log-level
Initform

log4cl-impl:+log-level-debug+

Readers

%expr-log-level.

Writers

(setf %expr-log-level).

Slot: old-logging-macros
Readers

%old-logging-macros.

Writers

(setf %old-logging-macros).

Class: pattern-layout

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.

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

layout.

Direct methods
Direct slots
Slot: %pattern
Initargs

:conversion-pattern

Readers

conversion-pattern.

Writers

(setf conversion-pattern).

Slot: %formatter
Class: property-configurator

Class that holds configurator state while parsing the properties file

Package

log4cl-impl.

Source

property-configurator.lisp.

Direct superclasses

property-parser.

Direct methods
Direct slots
Slot: loggers
Slot: additivity
Slot: appenders
Class: property-parser

Class for reading Java style property files.

Package

log4cl-impl.

Source

property-parser.lisp.

Direct subclasses

property-configurator.

Direct methods
Direct slots
Slot: name-token-separator
Initform

":"

Initargs

:separator

Slot: name-token-read-case
Initform

(readtable-case *readtable*)

Initargs

:read-case

Slot: %orig-initargs
Class: rolling-file-appender-base

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

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

file-appender-base.

Direct subclasses

daily-file-appender.

Direct methods
Direct slots
Slot: %rollover-check-period
Initform

60

Initargs

:rollover-check-period

Slot: %next-rollover-time
Initform

0

Class: serialized-appender

Appender that serializes itself using a lock

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

appender.

Direct subclasses

stream-appender.

Direct methods

appender-do-append.

Direct slots
Slot: %lock
Initform

(bordeaux-threads:make-recursive-lock "log4cl serialized appender lock")

Class: simple-layout

Simple layout outputs log level and user message separated by dash. For example: INFO - user log message

Package

log4cl-impl.

Source

simple-layout.lisp.

Direct superclasses

layout.

Direct methods

layout-to-stream.

Class: stream-appender

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

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

serialized-appender.

Direct subclasses
Direct methods
Direct slots
Slot: immediate-flush
Initargs

:immediate-flush

Slot: flush-interval
Initform

1

Initargs

:flush-interval

Slot: %last-flush-time
Initform

0

Slot: %output-since-flush
Class: temp-appender

A mixing for STREAM-APPENDER that will remove the appender if it encounters an error matching ERROR-TYPE

Package

log4cl-impl.

Source

appender.lisp.

Direct subclasses

this-console-appender.

Direct methods
Direct slots
Slot: error-type
Initform

(quote error)

Initargs

:error-type

Readers

temp-appender-error-type.

Writers

(setf temp-appender-error-type).

Class: this-console-appender

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

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses
Direct subclasses

tricky-console-appender.

Direct methods

shared-initialize.

Direct slots
Slot: stream
Package

common-lisp.

Initform

log4cl-impl:*global-console*

Class: tricky-console-appender

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

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

this-console-appender.

Direct methods

appender-do-append.


6.2 Internals


6.2.1 Constants

Constant: +logger-after-package-flag+
Package

log4cl-impl.

Source

defs.lisp.

Constant: +logger-category-depth-bits+
Package

log4cl-impl.

Source

defs.lisp.

Constant: package-ref-sym
Package

log4cl-impl.

Source

logger.lisp.


6.2.2 Special variables

Special Variable: %parse-line

Current line being parsed

Package

log4cl-impl.

Source

property-parser.lisp.

Special Variable: %parse-line-num

Current line number in the input stream

Package

log4cl-impl.

Source

property-parser.lisp.

Special Variable: *configurations*

List of all LOGGER-CONFIGURATION objects

Package

log4cl-impl.

Source

configurator.lisp.

Special Variable: *default-patterns*
Package

log4cl-impl.

Source

configurator.lisp.

Special Variable: *dotted-naming-configuration*

Naming configuration for dotted packages

Package

log4cl-impl.

Source

naming.lisp.

Special Variable: *formatters*
Package

log4cl-impl.

Source

pattern-layout.lisp.

Special Variable: *hierarchies*

Array of all hierarchies in the system

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *hierarchy-lock*

Global lock for changing logging configuration

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *hierarchy-max*

Number of hierarchies registered with the log4cl library. Each hierarchy has independent configuration with regards to log levels and appenders

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *hierarchy-watcher-heartbeat*

How long hierarchy watcher thread sleeps between calling WATCHER-HOOK of each hierarchy

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *inside-user-log-function*

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

log4cl-impl.

Source

defs.lisp.

Special Variable: *log-event-package-hint*

Package at call site or NIL if log statement had no literal symbols interned in *PACKAGE*

Package

log4cl-impl.

Source

defs.lisp.

Special Variable: *log-event-time*

Value of (GET-UNIVERSAL-TIME) for the current log event

Package

log4cl-impl.

Source

defs.lisp.

Special Variable: *name-to-hierarchy*

EQL hash table mapping hierarchy identifier to hierarchy index

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *naming-configurations*
Package

log4cl-impl.

Source

naming.lisp.

Special Variable: *self-log-config*
Package

log4cl-impl.

Source

self-logger.lisp.

Special Variable: *stop-semaphore*
Package

log4cl-impl.

Source

watcher.lisp.

Special Variable: *watcher-event-time*

Universal time of the current watcher heartbeat

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *watcher-thread*

The hierarchy watcher thread

Package

log4cl-impl.

Source

hierarchy-base.lisp.

Special Variable: *watcher-thread-bindings*

Extra bindings for watcher thread

Package

log4cl-impl.

Source

watcher.lisp.

Special Variable: +default-local-date-format+
Package

log4cl-impl.

Source

pattern-layout.lisp.

Special Variable: +log-level-from-letter+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +log-level-from-string+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +log-level-macro-symbols+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +log-level-symbols+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +log-level-to-keyword+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +log-level-to-lc-string+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +log-level-to-string+
Package

log4cl-impl.

Source

defs.lisp.

Special Variable: +make-logger-symbols+
Package

log4cl-impl.

Source

logging-macros.lisp.


6.2.3 Macros

Macro: define-category-depth-accessor (name1 name2 num)
Package

log4cl-impl.

Source

logger.lisp.

Macro: define-pattern-formatter ((char &optional stopchar) &body body)

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.

Package

log4cl-impl.

Source

pattern-layout.lisp.

Macro: deflog-macros (levels)
Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: deflog-sexp-macros (levels)
Package

log4cl-impl.

Source

logging-macros.lisp.

Macro: forward-function (name from-name)
Package

log4cl-impl.

Source

package.lisp.

Macro: forward-levels (levels)
Package

log4cl-impl.

Source

package.lisp.

Macro: forward-macro (name from-name &optional deprecate replacement)
Package

log4cl-impl.

Source

package.lisp.

Macro: forward-sexp-levels (levels)
Package

log4cl-impl.

Source

package.lisp.

Macro: package-options (&key package category-case category-separator shortest-nickname expr-print-format expr-log-level old-logging-macros &allow-other-keys)

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)

Package

log4cl-impl.

Source

configurator.lisp.

Macro: with-hierarchies-lock (&body body)
Package

log4cl-impl.

Source

hierarchy.lisp.

Macro: with-hierarchy-lock ((&optional hierarchy) &body body)
Package

log4cl-impl.

Source

hierarchy.lisp.

Macro: with-logged-problems (context &body body)
Package

log4cl-impl.

Source

watcher.lisp.

Macro: with-property-location ((location) &body body)

Run BODY with %PARSE-LINE and %PARSE-LINE-NUM bound to the remembered location, so that any errors signaled will have correct location

Package

log4cl-impl.

Source

property-parser.lisp.

Macro: with-small-dynamic-extent-vector ((name len len-expr &optional limit) &body body)
Package

log4cl-impl.

Source

pattern-layout.lisp.


6.2.4 Ordinary functions

Function: %%create-root-logger ()
Package

log4cl-impl.

Source

logger.lisp.

Function: %create-root-logger (&key category category-separator name-start-pos parent depth child-hash state dummy)
Package

log4cl-impl.

Source

logger.lisp.

Function: %hierarchy-index (name)
Package

log4cl-impl.

Source

hierarchy.lisp.

Reader: %logger-category (instance)
Writer: (setf %logger-category) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

category.

Reader: %logger-category-separator (instance)
Writer: (setf %logger-category-separator) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

category-separator.

Reader: %logger-child-hash (instance)
Writer: (setf %logger-child-hash) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

child-hash.

Reader: %logger-depth (instance)
Writer: (setf %logger-depth) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

depth.

Reader: %logger-name-start-pos (instance)
Writer: (setf %logger-name-start-pos) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

name-start-pos.

Reader: %logger-parent (instance)
Writer: (setf %logger-parent) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

parent.

Reader: %logger-state (instance)
Writer: (setf %logger-state) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

state.

Function: %set-package-options (&key package category-case category-separator expr-print-format shortest-nickname expr-log-level old-logging-macros)

Processes the naming configuration options

Package

log4cl-impl.

Source

configurator.lisp.

Function: add-appender-internal (logger appender &optional adjust-p)
Package

log4cl-impl.

Source

logger.lisp.

Function: adjust-all-loggers-state (new-len)
Package

log4cl-impl.

Source

logger.lisp.

Function: adjust-logger (logger)

Recalculate LOGGER mask by finding out which log levels have reachable appenders.

Package

log4cl-impl.

Source

logger.lisp.

Function: adjusted-logger-depth (logger)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: appender-extra-print-properties (a)

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

Package

log4cl-impl.

Source

configurator.lisp.

Function: apply-logging-configuration (cnf)

Restores logging configuration

Package

log4cl-impl.

Source

configurator.lisp.

Function: auto-named-p (cnf)

Test if logging configuration name was auto-generated

Package

log4cl-impl.

Source

configurator.lisp.

Function: call-user-log-message (log-func stream)

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

Package

log4cl-impl.

Source

logger.lisp.

Function: call-with-logged-problems (context thunk)
Package

log4cl-impl.

Source

watcher.lisp.

Function: check-arg (name value)
Package

log4cl-impl.

Source

defs.lisp.

Function: compile-pattern (layout pattern)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: compile-pattern-format (pattern &optional idx stopchar)

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.

Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: convert-read-case (string case)

Convert STRING according to CASE

Package

log4cl-impl.

Source

property-parser.lisp.

Function: copy-file-logger (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: copy-logger (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: copy-logger-state (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: copy-root-logger (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: copy-source-file-logger (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: create-appender-file (appender)
Package

log4cl-impl.

Source

appender.lisp.

Function: create-delayed-instance (instance)

First filter all properties through through INSTANCE-PROPERTY-FROM-STRING, and then create the instance

Package

log4cl-impl.

Source

property-configurator.lisp.

Function: create-file-logger (&key category category-separator name-start-pos parent depth child-hash state file)
Package

log4cl-impl.

Source

logger.lisp.

Function: create-logger (&key category category-separator name-start-pos parent depth child-hash state)
Package

log4cl-impl.

Source

logger.lisp.

Function: create-source-file-logger (&key category category-separator name-start-pos parent depth child-hash state file namestring)
Package

log4cl-impl.

Source

logger.lisp.

Function: current-hierarchy ()

Return the currently active hierarchy

Package

log4cl-impl.

Source

hierarchy.lisp.

Function: current-state (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: dotted-package-p (package)
Package

log4cl-impl.

Source

naming.lisp.

Function: ensure-naming-configuration (package)
Package

log4cl-impl.

Source

naming.lisp.

Function: exit-hook ()

Flushes all existing appenders

Package

log4cl-impl.

Source

watcher.lisp.

Function: expand-log-with-level (env level args)

Returns a FORM that is used as an expansion of log-nnnnn macros

Package

log4cl-impl.

Source

logger.lisp.

Function: expand-name-format (pattern time utc-p)
Package

log4cl-impl.

Source

appender.lisp.

Function: expr-log-level (&optional nc)
Package

log4cl-impl.

Source

naming.lisp.

Function: figure-out-pattern (&rest args)
Package

log4cl-impl.

Source

configurator.lisp.

Function: file-logger-category (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-category) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: file-logger-category-separator (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-category-separator) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: file-logger-child-hash (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-child-hash) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: file-logger-depth (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-depth) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Reader: file-logger-file (instance)
Writer: (setf file-logger-file) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

file.

Function: file-logger-name-start-pos (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-name-start-pos) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: file-logger-p (object)
Package

log4cl-impl.

Source

logger.lisp.

Function: file-logger-parent (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-parent) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: file-logger-state (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf file-logger-state) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: find-or-create-naming-configuration (p &optional createp)
Package

log4cl-impl.

Source

naming.lisp.

Function: format-categories (stream fmt-info cats num-cats separator)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: format-categories-range (stream fmt-info logger start-depth end-depth)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: format-log-date (stream fmt-info utc-p)

Helper function to print either %d or %D (date/time) pattern

Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: format-string (string stream info &optional start end)

Write STRING to the STREAM, respecting flags in info

Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: get-logger-internal (categories cat-sep cat-case &optional force-string-case createp file pkg-idx-start pkg-idx-end is-file-p)

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.

Package

log4cl-impl.

Alias for

%get-logger.

Function: have-appenders-for-level (logger level)

Return non-NIL if logging with LEVEL will actually reach any appenders

Package

log4cl-impl.

Source

logger.lisp.

Function: hierarchy-watcher-do-one-token (hier token)
Package

log4cl-impl.

Source

watcher.lisp.

Function: hierarchy-watcher-once ()

Do one iteration of watcher loop.

Package

log4cl-impl.

Source

watcher.lisp.

Function: include-block-debug-name? (debug-name)

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

Package

log4cl-impl.

Source

naming-sbcl.lisp.

Function: init-hook ()

Starts watcher thread if any existing appenders don’t have :immediate-flush option

Package

log4cl-impl.

Source

watcher.lisp.

Function: instantiate-logger (package categories explicitp createp)
Package

log4cl-impl.

Source

naming.lisp.

Function: intern-boolean (value)

Parse boolean value

Package

log4cl-impl.

Source

property-configurator.lisp.

Function: intern-class-name (string)
Package

log4cl-impl.

Source

property-configurator.lisp.

Function: is-enabled-for (logger level)

Returns t if log level is enabled for the logger in the context of the current application.

Package

log4cl-impl.

Source

logger.lisp.

Function: kw= (arg what)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: log-appender-disabled (appender condition)
Package

log4cl-impl.

Source

appender.lisp.

Function: log-event-package (logger)

Try to find the package at log event site. Can return NIL if package does not exist at runtime

Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: log-event-time ()

Returns the universal time of the current log event

Package

log4cl-impl.

Source

logger.lisp.

Function: log-level-to-lc-string (level)

Return lower case log-level string for the level

Package

log4cl-impl.

Source

logger.lisp.

Function: log-with-logger (logger level log-func package)

Submit message to logger appenders, and its parent logger

Package

log4cl-impl.

Source

logger.lisp.

Function: log4cl-style-warning (message &rest args)
Package

log4cl-impl.

Source

defs.lisp.

Function: logger-category-separator (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-child-hash (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-first-after-package-p (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-flags-depth (flags)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-flags-pkg-idx-end (flags)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-flags-pkg-idx-start (flags)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-name-length (logger)

Return length of logger itself (without parent loggers)

Package

log4cl-impl.

Source

logger.lisp.

Function: logger-name-start-pos (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-p (object)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-pkg-idx-end (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-pkg-idx-start (logger)
Package

log4cl-impl.

Source

logger.lisp.

Function: logger-state (logger)
Package

log4cl-impl.

Source

logger.lisp.

Reader: logger-state-additivity (instance)
Writer: (setf logger-state-additivity) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

additivity.

Reader: logger-state-appenders (instance)
Writer: (setf logger-state-appenders) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

appenders.

Reader: logger-state-level (instance)
Writer: (setf logger-state-level) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

level.

Reader: logger-state-mask (instance)
Writer: (setf logger-state-mask) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

mask.

Function: logger-state-p (object)
Package

log4cl-impl.

Source

logger.lisp.

Function: make-autosave-configuration ()
Package

log4cl-impl.

Source

configurator.lisp.

Function: make-log-expr-format (args)

Implement the parsing for (log:expr) arguments. Should return the list of arguments to FORMAT starting with control string

Package

log4cl-impl.

Source

naming.lisp.

Function: make-logger-configuration-load-form (logger)

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.

Package

log4cl-impl.

Source

configurator.lisp.

Function: make-logger-flags (depth &optional pkg-idx-start pkg-idx-end)
Package

log4cl-impl.

Source

logger.lisp.

Function: make-logger-state (&key appenders level additivity mask)
Package

log4cl-impl.

Source

logger.lisp.

Function: maybe-close-stream (appender)
Package

log4cl-impl.

Source

appender.lisp.

Function: maybe-flush-appender-stream (appender stream)

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

Package

log4cl-impl.

Source

appender.lisp.

Function: maybe-restore-configurations ()

If configurations list empty and *CONFIGURATIONS-FILE* exists in home directory restore configuration list from it

Package

log4cl-impl.

Source

configurator.lisp.

Function: maybe-start-watcher-thread ()
Package

log4cl-impl.

Source

watcher.lisp.

Function: next-time-boundary (time check-period)

Given universal time TIME return next boundary evenly divisible by CHECK-PERIOD seconds

Package

log4cl-impl.

Source

appender.lisp.

Function: parse-category-extra-args (fmt-info char pattern start)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: parse-category-precision (string)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: parse-date-format-extra-args (fmt-info utc-p pattern start)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: parse-extra-args-in-curly-braces (pattern start)

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")

Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: parse-logger-helper (parser keyword tokens value)

Common helper that handles both .rootLogger= and .logger.name= lines

Package

log4cl-impl.

Source

property-configurator.lisp.

Function: perform-default-init ()
Package

log4cl-impl.

Source

configurator.lisp.

Function: read-configurations-from-file (&optional file)
Package

log4cl-impl.

Source

configurator.lisp.

Function: remember-logging-configuration (&optional logger)

Utility method to make a list of logging configuration starting from LOGGER. Returns a list of CONFIGURATION-ELEMENT objects

Package

log4cl-impl.

Source

configurator.lisp.

Function: remove-all-appenders-internal (logger &optional adjust-p)
Package

log4cl-impl.

Source

logger.lisp.

Function: remove-appender-internal (logger appender &optional adjust-p)
Package

log4cl-impl.

Source

logger.lisp.

Function: replace-in-string (s x y)
Package

log4cl-impl.

Source

configurator.lisp.

Function: resolve-stream (stream)

Dereference synonym streams

Package

log4cl-impl.

Source

appender.lisp.

Function: root-logger-category (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-category) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: root-logger-category-separator (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-category-separator) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: root-logger-child-hash (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-child-hash) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: root-logger-depth (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-depth) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Reader: root-logger-dummy (instance)
Writer: (setf root-logger-dummy) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

dummy.

Function: root-logger-name-start-pos (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-name-start-pos) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: root-logger-p (object)
Package

log4cl-impl.

Source

logger.lisp.

Function: root-logger-parent (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-parent) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: root-logger-state (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf root-logger-state) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: safe-intern (name)
Package

log4cl-impl.

Source

naming-sbcl.lisp.

Function: save-all-appenders (&optional all-hierarchies)

Save all appenders, that is, clean up all resources.

Package

log4cl-impl.

Source

appender.lisp.

Function: save-configuration (cnf had-name-p)

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

Package

log4cl-impl.

Source

configurator.lisp.

Function: save-configurations-to-file (&optional file)
Package

log4cl-impl.

Source

configurator.lisp.

Function: save-hook ()

Flushes all existing appenders, and stops watcher thread

Package

log4cl-impl.

Source

watcher.lisp.

Function: sbcl-get-block-name (env)

Return a list naming SBCL lexical environment. For example when compiling local function FOO inside a global function FOOBAR, will return (FOOBAR FOO)

Package

log4cl-impl.

Source

naming-sbcl.lisp.

Function: set-additivity (logger additivity &optional adjust-p)

Set logger additivity.

Package

log4cl-impl.

Source

logger.lisp.

Function: set-delayed-instance-class (instance value)
Package

log4cl-impl.

Source

property-configurator.lisp.

Function: set-delayed-instance-property (instance tokens value)
Package

log4cl-impl.

Source

property-configurator.lisp.

Function: shortest-package-name (package)

Return the shortest name or nickname of the package

Package

log4cl-impl.

Source

naming.lisp.

Function: show-logger-settings (logger)

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

Package

log4cl-impl.

Source

configurator.lisp.

Function: simple-format-catogories (stream fmt-info logger start-depth end-depth)
Package

log4cl-impl.

Source

pattern-layout.lisp.

Function: source-file-logger-category (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-category) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: source-file-logger-category-separator (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-category-separator) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: source-file-logger-child-hash (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-child-hash) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: source-file-logger-depth (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-depth) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Reader: source-file-logger-file (instance)
Writer: (setf source-file-logger-file) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

file.

Function: source-file-logger-name-start-pos (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-name-start-pos) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Reader: source-file-logger-namestring (instance)
Writer: (setf source-file-logger-namestring) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Target Slot

namestring.

Function: source-file-logger-p (object)
Package

log4cl-impl.

Source

logger.lisp.

Function: source-file-logger-parent (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-parent) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: source-file-logger-state (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: (setf source-file-logger-state) (instance)
Package

log4cl-impl.

Source

logger.lisp.

Function: split-into-categories (category package)

Splits the category name into a list of categories from parent to child. Uses NAMING-OPTION to determine category separator

Package

log4cl-impl.

Source

logger.lisp.

Function: split-string (string separator &optional skip-whitespace-p)

Split the STRING into a list of strings. If SKIP-WHITESPACE-P is non-NIL strip whitespace from the string first

Package

log4cl-impl.

Source

logger.lisp.

Function: start/stop-watcher-hook (cmd &optional arg)
Package

log4cl-impl.

Source

watcher.lisp.

Function: strip-whitespace (string)

Strip tab and space characters from a string

Package

log4cl-impl.

Source

logger.lisp.

Function: substr (seq start &optional end)
Package

log4cl-impl.

Source

logger.lisp.

Function: trim-configuration-list (&optional var)

Trim the list in global variable VAR to at most *MAX-CONFIGURATIONS* elements

Package

log4cl-impl.

Source

configurator.lisp.

Function: use-shortest-nickname (&optional nc)
Package

log4cl-impl.

Source

naming.lisp.

Function: write-log-level (level stream)

Print the log LEVEL’s name to the STREAM

Package

log4cl-impl.

Source

simple-layout.lisp.

Function: write-string-modify-case (string stream &optional case start end)

Helper function that writes STRING to STREAM, optionally doing case conversion.

Package

log4cl-impl.

Source

naming.lisp.


6.2.5 Generic functions

Generic Reader: %category-case (object)
Package

log4cl-impl.

Methods
Reader Method: %category-case ((naming-configuration naming-configuration))

automatically generated reader method

Source

naming.lisp.

Target Slot

category-case.

Generic Writer: (setf %category-case) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf %category-case) ((naming-configuration naming-configuration))

automatically generated writer method

Source

naming.lisp.

Target Slot

category-case.

Generic Reader: %category-separator (object)
Package

log4cl-impl.

Methods
Reader Method: %category-separator ((naming-configuration naming-configuration))

automatically generated reader method

Source

naming.lisp.

Target Slot

category-separator.

Generic Writer: (setf %category-separator) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf %category-separator) ((naming-configuration naming-configuration))

automatically generated writer method

Source

naming.lisp.

Target Slot

category-separator.

Generic Reader: %expr-log-level (object)
Package

log4cl-impl.

Methods
Reader Method: %expr-log-level ((naming-configuration naming-configuration))

automatically generated reader method

Source

naming.lisp.

Target Slot

expr-log-level.

Generic Writer: (setf %expr-log-level) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf %expr-log-level) ((naming-configuration naming-configuration))

automatically generated writer method

Source

naming.lisp.

Target Slot

expr-log-level.

Generic Reader: %expr-print-format (object)
Package

log4cl-impl.

Methods
Reader Method: %expr-print-format ((naming-configuration naming-configuration))

automatically generated reader method

Source

naming.lisp.

Target Slot

expr-print-format.

Generic Writer: (setf %expr-print-format) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf %expr-print-format) ((naming-configuration naming-configuration))

automatically generated writer method

Source

naming.lisp.

Target Slot

expr-print-format.

Generic Reader: %old-logging-macros (object)
Package

log4cl-impl.

Methods
Reader Method: %old-logging-macros ((naming-configuration naming-configuration))

automatically generated reader method

Source

naming.lisp.

Target Slot

old-logging-macros.

Generic Writer: (setf %old-logging-macros) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf %old-logging-macros) ((naming-configuration naming-configuration))

automatically generated writer method

Source

naming.lisp.

Target Slot

old-logging-macros.

Generic Reader: %use-shortest-nickname (object)
Package

log4cl-impl.

Methods
Reader Method: %use-shortest-nickname ((naming-configuration naming-configuration))

automatically generated reader method

Source

naming.lisp.

Target Slot

use-shortest-nickname.

Generic Writer: (setf %use-shortest-nickname) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf %use-shortest-nickname) ((naming-configuration naming-configuration))

automatically generated writer method

Source

naming.lisp.

Target Slot

use-shortest-nickname.

Generic Reader: appender-filter (object)
Package

log4cl-impl.

Methods
Reader Method: appender-filter ((appender appender))

automatically generated reader method

Source

appender-base.lisp.

Target Slot

filter.

Generic Writer: (setf appender-filter) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf appender-filter) ((appender appender))

automatically generated writer method

Source

appender-base.lisp.

Target Slot

filter.

Generic Reader: condition-of (condition)
Generic Writer: (setf condition-of) (condition)
Package

log4cl-impl.

Methods
Reader Method: condition-of ((condition property-parser-error))
Writer Method: (setf condition-of) ((condition property-parser-error))
Source

property-parser.lisp.

Target Slot

condition.

Generic Reader: elements-of (object)
Package

log4cl-impl.

Methods
Reader Method: elements-of ((configuration configuration))

automatically generated reader method

Source

configurator.lisp.

Target Slot

elements.

Generic Writer: (setf elements-of) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf elements-of) ((configuration configuration))

automatically generated writer method

Source

configurator.lisp.

Target Slot

elements.

Generic Reader: filespec-of (object)
Package

log4cl-impl.

Methods
Reader Method: filespec-of ((property-configurator-file-watch property-configurator-file-watch))

automatically generated reader method

Source

property-configurator.lisp.

Target Slot

filespec.

Generic Writer: (setf filespec-of) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf filespec-of) ((property-configurator-file-watch property-configurator-file-watch))

automatically generated writer method

Source

property-configurator.lisp.

Target Slot

filespec.

Generic Reader: format-at-flag (object)
Package

log4cl-impl.

Methods
Reader Method: format-at-flag ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

at-flag.

Generic Reader: format-case (object)
Package

log4cl-impl.

Methods
Reader Method: format-case ((pattern-category-format-info pattern-category-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

case.

Generic Reader: format-colon-flag (object)
Package

log4cl-impl.

Methods
Reader Method: format-colon-flag ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

colon-flag.

Generic Reader: format-conversion-char (object)
Package

log4cl-impl.

Methods
Reader Method: format-conversion-char ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

conversion-char.

Generic Reader: format-date-format (object)
Package

log4cl-impl.

Methods
Reader Method: format-date-format ((pattern-date-format-info pattern-date-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

date-format.

Generic Reader: format-margin (object)
Package

log4cl-impl.

Methods
Reader Method: format-margin ((pattern-pretty-fmt-info pattern-pretty-fmt-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

margin.

Generic Reader: format-max-len (object)
Package

log4cl-impl.

Methods
Reader Method: format-max-len ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

maxlen.

Generic Reader: format-min-len (object)
Package

log4cl-impl.

Methods
Reader Method: format-min-len ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

minlen.

Generic Reader: format-package (object)
Package

log4cl-impl.

Methods
Reader Method: format-package ((pattern-pretty-fmt-info pattern-pretty-fmt-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

package.

Generic Reader: format-precision (object)
Package

log4cl-impl.

Methods
Reader Method: format-precision ((pattern-category-format-info pattern-category-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

precision.

Generic Reader: format-prefix (object)
Package

log4cl-impl.

Methods
Reader Method: format-prefix ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

prefix.

Generic Reader: format-pretty (object)
Package

log4cl-impl.

Methods
Reader Method: format-pretty ((pattern-pretty-fmt-info pattern-pretty-fmt-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

pretty.

Generic Reader: format-right-justify (object)
Package

log4cl-impl.

Methods
Reader Method: format-right-justify ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

right-justify.

Generic Reader: format-separator (object)
Package

log4cl-impl.

Methods
Reader Method: format-separator ((pattern-category-format-info pattern-category-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

separator.

Generic Reader: format-start (object)
Package

log4cl-impl.

Methods
Reader Method: format-start ((pattern-category-format-info pattern-category-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

start.

Generic Reader: format-suffix (object)
Package

log4cl-impl.

Methods
Reader Method: format-suffix ((format-info format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

suffix.

Generic Function: format-time (stream pattern universal-time utc-p)

Prints UNIVERSAL-TIME to the STREAM according to strftime like PATTERN.

Package

log4cl-impl.

Source

pattern-layout.lisp.

Methods
Method: format-time (stream pattern ut utc-p)
Generic Reader: format-universal-time (object)
Package

log4cl-impl.

Methods
Reader Method: format-universal-time ((pattern-date-format-info pattern-date-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

universal-time.

Generic Reader: format-utc-p (object)
Package

log4cl-impl.

Methods
Reader Method: format-utc-p ((pattern-date-format-info pattern-date-format-info))

automatically generated reader method

Source

pattern-layout.lisp.

Target Slot

utc-p.

Generic Reader: level-of (object)
Package

log4cl-impl.

Methods
Reader Method: level-of ((configuration-element configuration-element))

automatically generated reader method

Source

configurator.lisp.

Target Slot

level.

Generic Reader: line-num-of (condition)
Generic Writer: (setf line-num-of) (condition)
Package

log4cl-impl.

Methods
Reader Method: line-num-of ((condition property-parser-error))
Writer Method: (setf line-num-of) ((condition property-parser-error))
Source

property-parser.lisp.

Target Slot

line-num.

Generic Reader: line-of (condition)
Generic Writer: (setf line-of) (condition)
Package

log4cl-impl.

Methods
Reader Method: line-of ((condition property-parser-error))
Writer Method: (setf line-of) ((condition property-parser-error))
Source

property-parser.lisp.

Target Slot

line.

Generic Reader: logger-of (object)
Package

log4cl-impl.

Methods
Reader Method: logger-of ((configuration-element configuration-element))

automatically generated reader method

Source

configurator.lisp.

Target Slot

logger.

Generic Reader: name-of (object)
Package

log4cl-impl.

Methods
Reader Method: name-of ((configuration configuration))

automatically generated reader method

Source

configurator.lisp.

Target Slot

name.

Generic Writer: (setf name-of) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf name-of) ((configuration configuration))

automatically generated writer method

Source

configurator.lisp.

Target Slot

name.

Generic Function: parse-extra-args (fmt-info pattern-char pattern-string start)

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.

Package

log4cl-impl.

Source

pattern-layout.lisp.

Methods
Method: parse-extra-args (fmt-info (char (eql #\<)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\i)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\i)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\h)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\d)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\d)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\g)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\g)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\c)) pattern start)
Method: parse-extra-args (fmt-info (char (eql #\c)) pattern start)
Method: parse-extra-args (fmt-info character pattern start)

Default method does not parse any extra arguments and returns INFO unchanged

Generic Function: parse-property-keyword (parser keyword more-tokens value)

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)

Package

log4cl-impl.

Source

property-parser.lisp.

Methods
Method: parse-property-keyword ((parser property-configurator) (keyword (eql :appender)) tokens value)
Source

property-configurator.lisp.

Method: parse-property-keyword ((parser property-configurator) (keyword (eql :additivity)) tokens value)
Source

property-configurator.lisp.

Method: parse-property-keyword ((parser property-configurator) (keyword (eql :logger)) tokens value)
Source

property-configurator.lisp.

Method: parse-property-keyword ((parser property-configurator) (keyword (eql :rootlogger)) tokens value)
Source

property-configurator.lisp.

Method: parse-property-keyword ((parser 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

Source

property-configurator.lisp.

Generic Function: parse-property-line (parser name value)

Called for each NAME=VALUE line in the properties stream. Both NAME and VALUE are strings

Package

log4cl-impl.

Source

property-parser.lisp.

Methods
Method: parse-property-line ((parser 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

Generic Function: parse-property-tokens (parser tokens value)

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

Package

log4cl-impl.

Source

property-parser.lisp.

Methods
Method: parse-property-tokens ((parser property-parser) tokens value)

Interns the first element of TOKENS as a keyword, and forwards to PARSE-PROPERTY-KEYWORD

Generic Function: property-alist (instance)

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

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: property-alist ((instance daily-file-appender))
Source

appender.lisp.

Method: property-alist ((instance rolling-file-appender-base))
Source

appender.lisp.

Method: property-alist ((instance file-appender))
Source

appender.lisp.

Method: property-alist ((instance fixed-stream-appender))
Source

appender.lisp.

Method: property-alist ((instance fixed-stream-appender-base))
Source

appender.lisp.

Method: property-alist ((instance stream-appender))
Source

appender.lisp.

Method: property-alist ((instance appender))

Abstract appender has no properties

Source

appender.lisp.

Method: property-alist ((instance pattern-layout))
Source

pattern-layout.lisp.

Method: property-alist ((instance layout))

Abstract layout has no properties

Source

layout.lisp.

Generic Function: property-initarg-from-string (instance property value)

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

Package

log4cl-impl.

Source

appender-base.lisp.

Methods
Method: property-initarg-from-string (instance property value)

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

Source

property-configurator.lisp.

Generic Function: resolve-default-logger-form (package env args)

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

Package

log4cl-impl.

Source

naming.lisp.

Methods
Method: resolve-default-logger-form (package env args)

Returns the logger named after the enclosing lexical environment

Generic Reader: watch-tokens (object)
Package

log4cl-impl.

Methods
Reader Method: watch-tokens ((hierarchy hierarchy))

automatically generated reader method

Source

hierarchy-base.lisp.

Target Slot

watch-tokens.

Generic Writer: (setf watch-tokens) (object)
Package

log4cl-impl.

Methods
Writer Method: (setf watch-tokens) ((hierarchy hierarchy))

automatically generated writer method

Source

hierarchy-base.lisp.

Target Slot

watch-tokens.


6.2.6 Conditions

Condition: log4cl-style-warning
Package

log4cl-impl.

Source

defs.lisp.

Direct superclasses
  • simple-condition.
  • style-warning.

6.2.7 Structures

Structure: file-logger
Package

log4cl-impl.

Source

logger.lisp.

Direct superclasses

logger.

Direct methods

print-object.

Direct slots
Slot: file
Type

(or null log4cl-impl::source-file-logger)

Readers

file-logger-file.

Writers

(setf file-logger-file).

Structure: logger
Package

log4cl-impl.

Source

logger.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods
Direct slots
Slot: category
Type

simple-string

Readers

%logger-category.

Writers

(setf %logger-category).

Slot: category-separator
Type

simple-string

Readers

%logger-category-separator.

Writers

(setf %logger-category-separator).

Slot: name-start-pos
Type

fixnum

Initform

0

Readers

%logger-name-start-pos.

Writers

(setf %logger-name-start-pos).

Slot: parent
Type

(or null log4cl-impl::logger)

Readers

%logger-parent.

Writers

(setf %logger-parent).

Slot: depth
Type

fixnum

Initform

0

Readers

%logger-depth.

Writers

(setf %logger-depth).

Slot: child-hash
Type

(or null hash-table)

Readers

%logger-child-hash.

Writers

(setf %logger-child-hash).

Slot: state
Type

(simple-array log4cl-impl::logger-state *)

Initform

(map-into (make-array log4cl-impl::*hierarchy-max*) (function log4cl-impl::make-logger-state))

Readers

%logger-state.

Writers

(setf %logger-state).

Structure: logger-state
Package

log4cl-impl.

Source

logger.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: appenders
Type

list

Readers

logger-state-appenders.

Writers

(setf logger-state-appenders).

Slot: level
Type

(or null fixnum)

Readers

logger-state-level.

Writers

(setf logger-state-level).

Slot: additivity
Type

boolean

Initform

t

Readers

logger-state-additivity.

Writers

(setf logger-state-additivity).

Slot: mask
Type

fixnum

Initform

0

Readers

logger-state-mask.

Writers

(setf logger-state-mask).

Structure: root-logger
Package

log4cl-impl.

Source

logger.lisp.

Direct superclasses

logger.

Direct slots
Slot: dummy
Readers

root-logger-dummy.

Writers

(setf root-logger-dummy).

Structure: source-file-logger
Package

log4cl-impl.

Source

logger.lisp.

Direct superclasses

logger.

Direct methods

print-object.

Direct slots
Slot: file
Type

pathname

Readers

source-file-logger-file.

Writers

(setf source-file-logger-file).

Slot: namestring
Package

common-lisp.

Type

simple-string

Readers

source-file-logger-namestring.

Writers

(setf source-file-logger-namestring).


6.2.8 Classes

Class: delayed-appender
Package

log4cl-impl.

Source

property-configurator.lisp.

Direct superclasses

delayed-instance.

Direct slots
Slot: layout
Slot: name
Initargs

:name

Slot: used
Class: delayed-instance
Package

log4cl-impl.

Source

property-configurator.lisp.

Direct superclasses

property-location.

Direct subclasses
Direct slots
Slot: class
Package

common-lisp.

Slot: properties
Slot: extra-initargs
Slot: instance
Class: delayed-layout
Package

log4cl-impl.

Source

property-configurator.lisp.

Direct superclasses

delayed-instance.

Direct slots
Slot: name
Initargs

:name

Class: fixed-stream-appender-base

Appender that writes message to the stream in STREAM slot

Package

log4cl-impl.

Source

appender.lisp.

Direct superclasses

stream-appender.

Direct subclasses
Direct methods
Direct slots
Slot: stream
Package

common-lisp.

Readers

appender-stream.

Writers

(setf appender-stream).

Slot: stream-owner
Initargs

:stream-owner

Class: format-info

Represents data for a single conversion pattern

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: conversion-char
Type

character

Initargs

:conversion-char

Readers

format-conversion-char.

Writers

This slot is read-only.

Slot: minlen
Type

fixnum

Initform

0

Initargs

:minlen

Readers

format-min-len.

Writers

This slot is read-only.

Slot: maxlen
Type

(or null fixnum)

Initargs

:maxlen

Readers

format-max-len.

Writers

This slot is read-only.

Slot: right-justify
Type

boolean

Initargs

:right-justify

Readers

format-right-justify.

Writers

This slot is read-only.

Slot: prefix
Type

(or null simple-string)

Initargs

:prefix

Readers

format-prefix.

Writers

This slot is read-only.

Slot: suffix
Type

(or null simple-string)

Initargs

:suffix

Readers

format-suffix.

Writers

This slot is read-only.

Slot: colon-flag
Type

boolean

Initargs

:colon-flag

Readers

format-colon-flag.

Writers

This slot is read-only.

Slot: at-flag
Type

boolean

Initargs

:at-flag

Readers

format-at-flag.

Writers

This slot is read-only.

Class: hierarchy
Package

log4cl-impl.

Source

hierarchy-base.lisp.

Direct methods
Direct slots
Slot: name
Initargs

:name

Slot: index
Initargs

:index

Slot: watch-tokens
Readers

watch-tokens.

Writers

(setf watch-tokens).

Slot: %lock
Initform

(bordeaux-threads:make-recursive-lock "log4cl hierarchy lock")

Class: logger-record
Package

log4cl-impl.

Source

property-configurator.lisp.

Direct superclasses

property-location.

Direct slots
Slot: logger
Initargs

:logger

Slot: level
Initargs

:level

Slot: appender-names
Initargs

:appender-names

Class: pattern-category-format-info

Extra formatting flags for %c (log category) pattern

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

format-info.

Direct methods
Direct slots
Slot: precision
Initargs

:precision

Readers

format-precision.

Writers

This slot is read-only.

Slot: start
Initargs

:start

Readers

format-start.

Writers

This slot is read-only.

Slot: separator
Initargs

:separator

Readers

format-separator.

Writers

This slot is read-only.

Slot: case
Package

common-lisp.

Initargs

:case

Readers

format-case.

Writers

This slot is read-only.

Class: pattern-date-format-info

Extra formatting flags for %d and %D patterns

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

format-info.

Direct methods
Direct slots
Slot: date-format
Initargs

:date-format

Readers

format-date-format.

Writers

This slot is read-only.

Slot: universal-time
Initargs

:universal-time

Readers

format-universal-time.

Writers

This slot is read-only.

Slot: utc-p
Initargs

:utc-p

Readers

format-utc-p.

Writers

This slot is read-only.

Class: pattern-hostname-format-info

Extra formatting flags for %h pattern

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

format-info.

Direct slots
Slot: hostname
Initargs

:hostname

Class: pattern-log-indent-fmt-info

Extra formatting flags for %I (log indent) pattern

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

format-info.

Direct slots
Slot: indent-string
Initargs

:indent-string

Class: pattern-pretty-fmt-info

Extra formatting flags for %<...%> (pretty print) format

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

format-info.

Direct methods
Direct slots
Slot: pretty
Type

(or null (member :pretty :nopretty))

Initargs

:pretty

Readers

format-pretty.

Writers

This slot is read-only.

Slot: margin
Initargs

:margin

Readers

format-margin.

Writers

This slot is read-only.

Slot: package
Package

common-lisp.

Type

(or null (member :package :nopackage))

Initargs

:package

Readers

format-package.

Writers

This slot is read-only.

Class: process-id-fmt-info

Caches process-id

Package

log4cl-impl.

Source

pattern-layout.lisp.

Direct superclasses

format-info.

Direct slots
Slot: process-id
Initargs

:process-id

Class: property-configurator-file-watch
Package

log4cl-impl.

Source

property-configurator.lisp.

Direct methods
Direct slots
Slot: filespec
Initargs

:filespec

Readers

filespec-of.

Writers

(setf filespec-of).

Slot: time
Package

common-lisp.

Initargs

:time

Slot: configurator
Initargs

:configurator

Class: property-location

Remembered line and line number in the input
stream where object appeared, so we can signal errors with that info

Package

log4cl-impl.

Source

property-parser.lisp.

Direct subclasses
Direct slots
Slot: line
Initform

log4cl-impl::%parse-line

Slot: line-num
Initform

log4cl-impl::%parse-line-num


6.2.9 Types

Type: logger-cat-idx ()
Package

log4cl-impl.

Source

defs.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   R   S   T   U   W  
<
Index Entry  Section

%
%%create-root-logger: Private ordinary functions
%category-case: Private generic functions
%category-case: Private generic functions
%category-separator: Private generic functions
%category-separator: Private generic functions
%create-root-logger: Private ordinary functions
%expr-log-level: Private generic functions
%expr-log-level: Private generic functions
%expr-print-format: Private generic functions
%expr-print-format: Private generic functions
%get-logger: Public ordinary functions
%hierarchy-index: Private ordinary functions
%logger-category: Private ordinary functions
%logger-category-separator: Private ordinary functions
%logger-child-hash: Private ordinary functions
%logger-depth: Private ordinary functions
%logger-name-start-pos: Private ordinary functions
%logger-parent: Private ordinary functions
%logger-state: Private ordinary functions
%old-logging-macros: Private generic functions
%old-logging-macros: Private generic functions
%set-package-options: Private ordinary functions
%use-shortest-nickname: Private generic functions
%use-shortest-nickname: Private generic functions

(
(setf %category-case): Private generic functions
(setf %category-case): Private generic functions
(setf %category-separator): Private generic functions
(setf %category-separator): Private generic functions
(setf %expr-log-level): Private generic functions
(setf %expr-log-level): Private generic functions
(setf %expr-print-format): Private generic functions
(setf %expr-print-format): Private generic functions
(setf %logger-category): Private ordinary functions
(setf %logger-category-separator): Private ordinary functions
(setf %logger-child-hash): Private ordinary functions
(setf %logger-depth): Private ordinary functions
(setf %logger-name-start-pos): Private ordinary functions
(setf %logger-parent): Private ordinary functions
(setf %logger-state): Private ordinary functions
(setf %old-logging-macros): Private generic functions
(setf %old-logging-macros): Private generic functions
(setf %use-shortest-nickname): Private generic functions
(setf %use-shortest-nickname): Private generic functions
(setf appender-enabled-p): Public generic functions
(setf appender-enabled-p): Public generic functions
(setf appender-error-count): Public generic functions
(setf appender-error-count): Public generic functions
(setf appender-filter): Private generic functions
(setf appender-filter): Private generic functions
(setf appender-ignored-error-count): Public generic functions
(setf appender-ignored-error-count): Public generic functions
(setf appender-last-error): Public generic functions
(setf appender-last-error): Public generic functions
(setf appender-last-ignored-error): Public generic functions
(setf appender-last-ignored-error): Public generic functions
(setf appender-layout): Public generic functions
(setf appender-layout): Public generic functions
(setf appender-logger-count): Public generic functions
(setf appender-logger-count): Public generic functions
(setf appender-loggers): Public generic functions
(setf appender-loggers): Public generic functions
(setf appender-message-count): Public generic functions
(setf appender-message-count): Public generic functions
(setf appender-stream):