Common Lisp Package: LOG4CL

README:

Quickstart ## Installation and loading

From QuickLisp

LOG4CL is now included in QuickLisp. To load it use the command (ql:quickload :log4cl) from REPL. If QuickLisp can't find it, you need to update your QuickLisp distribution.

Latest GIT version

To use the latest GIT version, which may contain improvements and bug fixes not yet available in QuickLisp, you can use QuickLisp's local-projects feature.

$ cd ~/quicklisp/local-projects  
$ git clone git://github.com/7max/log4cl.git 

Then use the (ql:quickload :log4cl) from REPL to load it.

Log4CL packages

Do not try to include LOG4CL into your package's :USE list, instead use log: package prefix with your log statements.

The Basics

 (log:info "Hello World")  
 
     [14:39:03] [info] <cl-user> - Hello World  
 
 (log:i "I'm really lazy")  
 
     [14:39:08] [info] <cl-user> - I'm really lazy  
 
 (log:debug "something") 

As you can see package contains one letter shortcuts for all the log levels, for the lazy amongst us. Also note that debug log statement did not produce any output. Changing the log level is easy:

(log:config :debug)  
 
(log:debug "something")  
 
[14:41:44] [debug] <cl-user> - something 

As with the log statements, you can abbreviate config and :debug to one letter, for example: (log:c :d)

One additional logging utility function (log:expr), helps you to quickly debug values of variables and expressions:

(let ((a 1) (b 2))  
  (log:expr a b (+ a b)))  
 
[14:54:39] [debug] <cl-user> - A=1 B=2 (+ A B)=3 

It function also has two aliases: (log:sexp) and (log:s). For completeness there are also (log:sexp-trace), (log:sexp-info) and so on, to allow for same expression logging with any log level

Log severity levels LOG4CL has all the same log levels that Log4J does, and some additional ones. They are in the order of decreasing severity: fatal, error, warn, info, debug, user1 through user4, trace, and finally user5 through user9

There is also two special log levels off and unset, which turn the logging off, and inherit the log level from the parent logger. The default log level for all loggers is unset.

When a logging is on for a log level, it is also enabled for levels with more severity. For example if debug level is on, then info and error are also on.

How to determine if logging is on programatically?

Sometimes its useful to conditionally execute log statements. The logging macro without any arguments, will return T if logging is on:

(when (log:debug)  
  (print-detailed-debugging-info)) 

Loggers and categories

You may have noticed that the log output in addition to the time of the log message, its severity level and the actual log message, contains the string &lt;cl-user&gt;, which corresponds to the current package.

That string is the category of the log message, and is also referred to as logger's category, or simply a logger.

Logger is an object, that acts as source of the log message, and also as a configuration point, which can have its own log level and appenders. Log messages are always logged into a specific logger object.

Loggers form a hierarchy, starting from the root logger. Each logger can have child loggers, and these loggers can have their own child loggers and so on. The full category name of the logger, is concatenation of all the parent logger names starting from the root logger, with some separator string, which defaults to ":"

So for a logger A which has a child logger B, which in turn has child logger C, the full category name of the logger C is A:B:C

Automatic naming of loggers

When you issue a log statement such as (log:info "whatever") LOG4CL determines the logger name automatically based on surrounding context. That's why, when you issue log statement from REPL with the current package being CL-USER, the logger message went to was also called CL-USER.

You can directly instantiate logger objects, by using the (log:make-logger) function:

(log:make-logger)  
 
#<LOGGER CL-USER>  
 
(log:make-logger :a)  
 
#<LOGGER CL-USER:A>  
 
(log:make-logger '(one two three))  
 
#<LOGGER ONE:TWO:THREE>

In the first example, the logger name is automatically determined from context, as with the default log statement. In the second example, specifying a keyword as the logger name, will create a sub-logger of such default logger. And finally the most generic syntax is using a quoted list, where each element names a logger starting from root.

When submitting a log message, you can specify a logger object as a first argument:

(log:info (log:make-logger :a) "goes to logger A")  
 
[15:14:51] [info] <cl-user:a> - goes to logger A  
 
(log:info (log:make-logger '(one two three)) "goes to logger ONE:TWO:THREE")  
 
[15:15:04] [info] <one:two:three> - goes to logger ONE:TWO:THREE 

As a shortcut you can omit the (log:make-logger) and specify a (make-logger) argument directly as a first argument of a logging function, with exception of (log:expr) and friends.

(log:info '(one two three) "goes to logger ONE:TWO:THREE")  
 
[15:18:02] [info] <one:two:three> - goes to logger ONE:TWO:THREE  
 
(log:info :b "goes to logger CL-USER:B")  
 
[15:18:15] [info] <cl-user:b> - goes to logger CL-USER:B 

Automatic naming inside a function

Under SBCL automatic logger naming goes farther then naming the logger after the current package:

(defun foo (x)  
  (log:expr x (1+ x)))  
 
(foo 3)  
 
[16:47:09] [debug] <cl-user:foo> - X=3 (1+ X)=4  
 
(defun foo (x)  
  (flet ((baz ()  
           (log:expr x (1+ x))))  
    (baz)))  
 
(foo 3)  
 
[16:47:09] [debug] <cl-user:foo:baz> - X=3 (1+ X)=4 

It also handles methods:

(defmethod bar ((x number) y)  
  (flet ((baz ()  
    (log:expr x (1+ x) y)))  
       (baz)))  
 
(bar 3 'foo)  
 
[16:52:15] [debug] <cl-user:bar:number:baz> - X=3 (1+ X)=4 Y=FOO  
 
(defmethod bar :before (x y) (log:info "what happens before ~s ~s" x y))  
 
(bar 41 t)  
 
 
[16:55:11] [info] <cl-user:bar:before> - what happens before 41 T  
[16:55:11] [debug] <cl-user:bar:number:baz> - X=41 (1+ X)=42 Y=T 

Configuring a specific logger category

By default a call to (log:config) function configures the root logger. All the rest of the loggers in the system inherit the log level from their parent loggers, and eventually from the root logger.

It is possible to configure each logger to have its own log level, which will override the one inherited from the parent:

(log-config '(cl-user a) :debug)  
(log-config '(cl-user b) :trace)  
(log-config '(cl-user) :info)  
 
(log:info "this is info")  
 
[15:26:50] [info] <cl-user> - this is info  
 
(log:debug "this is debug")  
 
(log:debug :a "this is debug")  
 
[15:27:05] [debug] <cl-user:a> - this is debug  
 
(log:trace :a "this is trace")  
 
(log:trace :b "this is trace")  
 
[15:27:22] [trace] <cl-user:b> - this is trace   

In the above example we had configured logger CL-USERCL-USER:A and CL-USER:B with the info, debug and trace log levels, and tested submitting log messages to them. To make logger inherit its log level from its parent again, use the log level unset or use the :clear option of the configuration function.

(log:config '(cl-user) :unset)  
 
(log:debug "test")  
 
[15:34:37] [debug] <cl-user> - test  
 
(log:config '(cl-user) :info :clear)  
 
(log:debug :a "this is debug) 

Note: :clear option resets the log level of all the child loggers of the specified logger, but not the logger itself. To do both use (log:config '(logger) :unset :clear)

Displaying logger hierarchy configuration

Without any arguments, (log:config) will display logging hierarchy and its configuration on the standard output. It only prints "interesting" loggers, that have either an explicit log level, have any appenders, or are non-additive (meaning they don't propagate messages to the ancestor's appenders)

CL-USER> (log:config)  
ROOT, DEBUG  
|  
+-#<CONSOLE-APPENDER {102576AD21}>  
|     with #<PATTERN-LAYOUT {102566A5E1}>  
|          :conversion-pattern "[%D{%H:%M:%S}] [%P] <%c{}{}{:downcase}> - %m%n"  
|     :immediate-flush NIL  
|     :flush-interval  1  
|  
+-LOG4CL-IMPL  
  |  
  +-SELF (non-additive), WARN  
    |  
    +-#<CONSOLE-APPENDER {101EAEB6B1}>  
          with #<PATTERN-LAYOUT {101E55FC21}>  
               :conversion-pattern "[%d{%H:%M:%S}] [%-5P] <%c{}{}{:downcase}>%n  *%I{>} %m%n"  
          :immediate-flush NIL  
          :flush-interval  1  
CL-USER>

Appenders and layouts

While loggers are logical sinks for the log messages, appenders are physical ones, that are responsible for formatting the log messages and delivering them to their ultimate destination.

For example CONSOLE-APPENDER writes message to *DEBUG-IO* stream and DAILY-FILE-APPENDER writes messages into a file that rolls over each day.

Layouts

Appenders format the log messages by means of layouts. Layout receives information about logging event, and the stream to print output into, and is responsible for actual formatting of the message, such as adding timestamps or other formatting.

LOG4CL provides two layout classes:

  • SIMPLE-LAYOUT formats the message in a very primitive way, by printing the log level followed by a dash and the user log message

  • PATTERN-LAYOUT formats the message by specifying a conversion pattern string, which has escape sequences for various part of the log message. See Lisp docstring for PATTERN-LAYOUT class for the description of the pattern layout elements.

Configuring appenders and layouts with (log:config) function

The versatile (log:config) function can also add and remove appenders and their layouts. See the Lisp docstring for full description, below are a few examples:

  • :SANE option removes all appenders from the logger, and adds a LOG:CONSOLE-APPENDER with a pattern layout used in throughout the examples in this document
        (log:config :sane)  
     
        (log:info "test")  
     
        [15:54:04] [info] <cl-user> - test 
  • :TWOLINE option changes the pattern layout used to have output on two lines, the header line with time-stamp, log level, and logger's category, and second line with the actual log message.
          (log:config :sane :twoline)  
     
          (log:info "test")  
     
          [15:56:14] [ info] <cl-user>  
            * test  
    
  • :DAILY option adds a LOG:DAILY-FILE-APPENDER, logging into the specified file. The file will switch at midnight, with the old file renamed by adding &lt;year&gt;&lt;mon&gt;&lt;day&gt; suffix to its name.
          (log:config :daily "log.txt")  
     
          (log:info "test")  
     
          [15:56:14] [ info] <cl-user>  
            * test  
     
          $ cat log.txt  
          [15:58:50] [info] <cl-user> - test  
      It will use same pattern layout as the *:sane* option, it will also  
      accept *:twoline*. If both *:sane* and *:daily* are used, then  
      console appender is not added, you can use *:console* option to  
      force adding both file and console appenders. 
  • :PATTERN option allows one to change the conversion pattern for the new pattern layout used with new appenders added by :sane, :daily and/or :console options
          (log:config :sane :pattern "%d -- %p -- %m%n")  
     
          (log:info "test")  
     
          2012-02-23 21:05:12 -- INFO -- test 
  • :PROPERTIES option configures logging system from Log4J style properties file. There are important differences from Log4J:

  • Logging configuration lines start with log4cl instead of log4j

  • The default separator is colon instead of dot, similar to log category names

          $ cat tests/log4cl.properties  
     
          log4cl:rootLogger = INFO, file1, console  
          log4cl:appender:console = log4cl:console-appender  
          log4cl:appender:console:layout = log4cl:pattern-layout  
          log4cl:appender:console:layout:conversion-pattern =    |%p| |%c| - %m%n  
          log4cl:appender:file1 = log4cl:file-appender  
          log4cl:appender:file1:file = /tmp/logfile.txt  
          log4cl:appender:file1:immediate-flush = true  
     
          (log:config :properties "tests/log4cl.properties")  
     
          (log:info "testing")  
     
              |INFO| |CL-USER| - testing  
     
          $ cat /tmp/logfile.txt  
     
          INFO - testing  
      Note that whitespace is not stripped from the start of conversion  
      pattern property, but is stripped from the beginning of the  
      file-name property. 
  • :WATCH option together with :PROPERTIES option, will make LOG4CL watch the file modification time, and reload it when it changes.
          (log:config :properties "tests/log4cl.properties" :watch)  
     
          (log:info "testing")  
     
              |INFO| |CL-USER| - testing  
     
          $ cat /tmp/logfile.txt  
     
          INFO - testing  
      Now modify and save the *log4cl.properites* file. 
          |INFO| |LOG4CL| - Re-configured logging from tests/log4cl.properties  
  Now modify the file to have some error 
      |ERROR| |LOG4CL| - Re-configuring from tests/log4cl.properties failed:  
      "log4cl:appender:console:layout:conversion-patter =    |%p| |%c| - %m%n"  
      Error at line 6:  
      Unknown property :CONVERSION-PATTER for class #<PATTERN-LAYOUT  
                                                      {10761F4841}>

Quick save/restore

Once you added extensive logging to the your application, it may become bothersome to reconfigure log levels each time you work on a separate part of a big system.

For example, when focusing one module A, you need detailed debugging for it, but when focusing on module B, the debug statements coming from A flooding your screen are unhelpful. Of course one can use separate log4cl.properties file for each part of theh system that you are developing, or have a separate .lisp file with (log:config) statemements, but LOG4CL now provides a more intuitive and agile facility.

LTR> (log:save :config-1)  
 
#<log4cl-impl:logging-configuration :config-1 (18)>  
 
LTR> (log:config :clear :info)  
LTR> (log:save)  
 
#<log4cl-impl:configuration "Saved on 2012-07-01 12:51:02" (1)>  
 
LTR> (log:restore)  
 
#<log4cl-impl:configuration :config-1 (18)>  
 
LTR> (log:restore)  
 
#<log4cl-impl:configuration "Saved on 2012-07-01 11:44:18" (1)>  
 
LTR> (log:list-configurations)  
  0. #<CONFIGURATION "Saved on 2012-07-01 11:44:18" (1)>  
  1. #<CONFIGURATION :CONFIG-1 (18)>  
 
(log:restore 1)  
 
#<log4cl-impl:configuration :config-1 (18)>  
 
LTR> (log:config '(ltr scaling.lisp) :trace)  
LTR> (log:save :config2)  
 
#<log4cl-impl:configuration :config2 (19)>  
 
LTR> (log:list-configurations)  
  0. #<CONFIGURATION :CONFIG2 (19)>  
  1. #<CONFIGURATION :CONFIG-1 (18)>  
  2. #<CONFIGURATION "Saved on 2012-07-01 11:44:18" (1)>

The (log:save) function saves the logging configuration and (log:restore) restores last saved configuration.. There are up to 30 configuration saved, and they are automatically persisted into the ~/.log4cl-configurations.lisp-expr file, so they survive lisp restarts. When restore function notices that current configuration is not in the configuration list, it will automatically create a "Autosave on <timestamp>" configuration, so you can recover from accidents.

log:save and log:restore are also aliased to log:push and log:pop.

More documentation

Hopefully this Quick-Start guide covered enough to get you up and running, and using basic logging in your application.

Description of the more advanced features, such as logging hierarchies, and how to customize LOG4CL by adding your own appenders and layouts, or customizing auto-naming will be covered later once user manual is finished.

For now, you can browse the source code, where most generic functions, classes and methods have detailed docstrings. When doing so, please note that LOG4CL is simply a forwarder package, intended to be used only for log statements, and not for any customizations; the actual implementation of LOG4CL lives in the LOG4CL-IMPL package, which exports everything needed to for writing your own appenders and layouts. You can start with src/appender.lisp if you are looking for examples.

FUNCTION

Public

ADD-APPENDER (LOGGER APPENDER)

Adds appender to the logger

ADD-WATCH-TOKEN (TOKEN &KEY (TEST #'EQUAL) KEY (HIERARCHY (CURRENT-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

ALL-CONFIGURATIONS

Returns the *CONFIGURATIONS* list

C (&REST ARGS)

User friendly way of configuring loggers. General syntax is: (LOG-CONFIG [LOGGER-IDENTIFIER] OPTION1 OPTION2...) LOGGER-IDENTIFIER can be one of: * Logger instance ie result of (make-logger) expansion, or any form that returns a logger. * A list of logger categories, basically a shortcut for (MAKE-LOGGER '(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 (MAKE-LOGGER ...) ...) If not specified, default logger will be root logger Valid options can be: Option | Description ---------------|--------------------------------------------------------------- :INFO | Or any other keyword identifying a log level, which can be :DEBUG | shortened to its shortest unambiguous prefix, such as :D ---------------|--------------------------------------------------------------- :CLEAR | Removes log level and appenders from any child loggers, | appenders are not removed from non-additive loggers ---------------|--------------------------------------------------------------- :ALL | Changes :CLEAR to remove appenders from non-additive | loggers ---------------|--------------------------------------------------------------- :SANE | Removes logger appenders, adds console appender with | pattern layout that makes messages look like this: | | [11:22:25] INFO {category.name} - message | | If used with :DAILY then console appender is not added, unless | :CONSOLE or :THIS-CONSOLE is explicitly used ---------------|--------------------------------------------------------------- :DAILY FILE | Adds file appender logging to the named file, which will | be rolled over every midnight into FILE.YYYYMMDD; Removes any | other FILE-APPENDER-BASE'ed appenders from the logger ---------------|--------------------------------------------------------------- :CONSOLE | Adds CONSOLE-APPENDER to the logger. Console appender logs | into the *DEBUG-IO* at the call site. | :THIS-CONSOLE | Adds FIXED-STREAM-APPENDER to the logger, with :stream argument | taken from the current value of *DEBUG-IO* ---------------|--------------------------------------------------------------- :STREAM stream | Adds FIXED-STREAM-APPENDER logging to specified stream ---------------|--------------------------------------------------------------- :PATTERN | For any new appenders added, specifies the conversion pattern for the | PATTERN-LAYOUT ---------------|--------------------------------------------------------------- :TWOLINE | Changes default pattern layout to print user log message or :2LINE | log message on 2nd line after the headers ---------------|--------------------------------------------------------------- :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. ---------------|--------------------------------------------------------------- :OWN | For :SANE and :DAILY makes logger non-additive | otherwise additive flag will be set ---------------|--------------------------------------------------------------- Examples: * (LOG-CONFIG :D) -- Changes root logger level to debug * (LOG-CONFIG :SANE) -- Changes root logger level to info, removes its appenders, adds console appender with pattern layout * (LOG-CONFIG :SANE :THIS-CONSOLE) -- Same as above but adds fixed stream appender logging to current value of *DEBUG-IO* instead of regular console appender.. * (LOG-CONFIG :WARN :SANE :CLEAR :ALL) -- Changes root logger level to warnings, removes its appenders, adds console appender with pattern layout; then resets all child loggers log levels, and removes their appenders. * (LOG-CONFIG (MAKE-LOGGER :FOOBAR) :SANE :OWN :D :DAILY "debug.log") Configures the specified logger with debug log level, logging into file debug.log which will be rolled over daily, and makes it non-additive ie any messages will not be propagated to logger parents.

CLEAR-LOGGING-CONFIGURATION

Delete all loggers configuration, leaving only LOG4CL.SELF

CONFIG (&REST ARGS)

User friendly way of configuring loggers. General syntax is: (LOG-CONFIG [LOGGER-IDENTIFIER] OPTION1 OPTION2...) LOGGER-IDENTIFIER can be one of: * Logger instance ie result of (make-logger) expansion, or any form that returns a logger. * A list of logger categories, basically a shortcut for (MAKE-LOGGER '(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 (MAKE-LOGGER ...) ...) If not specified, default logger will be root logger Valid options can be: Option | Description ---------------|--------------------------------------------------------------- :INFO | Or any other keyword identifying a log level, which can be :DEBUG | shortened to its shortest unambiguous prefix, such as :D ---------------|--------------------------------------------------------------- :CLEAR | Removes log level and appenders from any child loggers, | appenders are not removed from non-additive loggers ---------------|--------------------------------------------------------------- :ALL | Changes :CLEAR to remove appenders from non-additive | loggers ---------------|--------------------------------------------------------------- :SANE | Removes logger appenders, adds console appender with | pattern layout that makes messages look like this: | | [11:22:25] INFO {category.name} - message | | If used with :DAILY then console appender is not added, unless | :CONSOLE or :THIS-CONSOLE is explicitly used ---------------|--------------------------------------------------------------- :DAILY FILE | Adds file appender logging to the named file, which will | be rolled over every midnight into FILE.YYYYMMDD; Removes any | other FILE-APPENDER-BASE'ed appenders from the logger ---------------|--------------------------------------------------------------- :CONSOLE | Adds CONSOLE-APPENDER to the logger. Console appender logs | into the *DEBUG-IO* at the call site. | :THIS-CONSOLE | Adds FIXED-STREAM-APPENDER to the logger, with :stream argument | taken from the current value of *DEBUG-IO* ---------------|--------------------------------------------------------------- :STREAM stream | Adds FIXED-STREAM-APPENDER logging to specified stream ---------------|--------------------------------------------------------------- :PATTERN | For any new appenders added, specifies the conversion pattern for the | PATTERN-LAYOUT ---------------|--------------------------------------------------------------- :TWOLINE | Changes default pattern layout to print user log message or :2LINE | log message on 2nd line after the headers ---------------|--------------------------------------------------------------- :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. ---------------|--------------------------------------------------------------- :OWN | For :SANE and :DAILY makes logger non-additive | otherwise additive flag will be set ---------------|--------------------------------------------------------------- Examples: * (LOG-CONFIG :D) -- Changes root logger level to debug * (LOG-CONFIG :SANE) -- Changes root logger level to info, removes its appenders, adds console appender with pattern layout * (LOG-CONFIG :SANE :THIS-CONSOLE) -- Same as above but adds fixed stream appender logging to current value of *DEBUG-IO* instead of regular console appender.. * (LOG-CONFIG :WARN :SANE :CLEAR :ALL) -- Changes root logger level to warnings, removes its appenders, adds console appender with pattern layout; then resets all child loggers log levels, and removes their appenders. * (LOG-CONFIG (MAKE-LOGGER :FOOBAR) :SANE :OWN :D :DAILY "debug.log") Configures the specified logger with debug log level, logging into file debug.log which will be rolled over daily, and makes it non-additive ie any messages will not be propagated to logger parents.

EFFECTIVE-APPENDERS (LOGGER)

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

EFFECTIVE-LOG-LEVEL (LOGGER)

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

LIST-CONFIGURATIONS (&OPTIONAL (STREAM *STANDARD-OUTPUT*))

Prints the *CONFIGURATIONS* list

LOGGER-ADDITIVITY (LOGGER)

Return logger additivity

SETFLOGGER-ADDITIVITY (ADDITIVITY LOGGER)

Set logger appender additivity. Returns new additivity

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

LOGGER-CATEGORY (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOGGER-CHILDREN (LOGGER)

Return a list of LOGGER's direct children

LOGGER-DEPTH (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LOGGER-DESCENDANTS (LOGGER)

Return a list of LOGGER's descendants

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

SETFLOGGER-LOG-LEVEL (LEVEL LOGGER)

Set logger log level. Returns logger own log level

LOGGER-NAME (LOGGER)

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

LOGGER-PARENT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

MAP-LOGGER-CHILDREN (FUNCTION LOGGER)

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

MAP-LOGGER-DESCENDANTS (FUNCTION LOGGER)

Apply the function to all of logger's descendants

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

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

REMOVE-ALL-APPENDERS (LOGGER)

Removes all appenders from the logger.

REMOVE-APPENDER (LOGGER APPENDER)

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

REMOVE-WATCH-TOKEN (TOKEN &KEY (TEST #'EQUAL) KEY (HIERARCHY (CURRENT-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

RESET-LOGGING-CONFIGURATION

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

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

SAME-CONFIGURATION-P (C1 C2)

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

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

Undocumented

LOG4CL-ERROR (MESSAGE &REST ARGS)

SETFLOGGER-CATEGORY (NEW-VALUE INSTANCE)

SETFLOGGER-DEPTH (NEW-VALUE INSTANCE)

SETFLOGGER-PARENT (NEW-VALUE INSTANCE)

START-HIERARCHY-WATCHER-THREAD

STOP-HIERARCHY-WATCHER-THREAD

MACRO

Public

D (&REST ARGS &ENVIRONMENT ENV)

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.

DEBUG (&REST ARGS &ENVIRONMENT ENV)

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.

E (&REST ARGS &ENVIRONMENT ENV)

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.

ERROR (&REST ARGS &ENVIRONMENT ENV)

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.

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)

F (&REST ARGS &ENVIRONMENT ENV)

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.

FATAL (&REST ARGS &ENVIRONMENT ENV)

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.

I (&REST ARGS &ENVIRONMENT ENV)

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.

IN-HIERARCHY (&OPTIONAL HIERARCHY)

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

IN-PACKAGE-HIERARCHY

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

INFO (&REST ARGS &ENVIRONMENT ENV)

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.

LOG-SEXP-WITH-LEVEL (LEVEL &REST SEXPS &ENVIRONMENT ENV)

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

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)

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)

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)

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)

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)

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)

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)

SEXP-USER1 (&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)

SEXP-USER2 (&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)

SEXP-USER3 (&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)

SEXP-USER4 (&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)

SEXP-USER5 (&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)

SEXP-USER6 (&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)

SEXP-USER7 (&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)

SEXP-USER8 (&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)

SEXP-USER9 (&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)

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)

T (&REST ARGS &ENVIRONMENT ENV)

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.

TRACE (&REST ARGS &ENVIRONMENT ENV)

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.

U1 (&REST ARGS &ENVIRONMENT ENV)

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.

U2 (&REST ARGS &ENVIRONMENT ENV)

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.

U3 (&REST ARGS &ENVIRONMENT ENV)

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.

U4 (&REST ARGS &ENVIRONMENT ENV)

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.

U5 (&REST ARGS &ENVIRONMENT ENV)

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.

U6 (&REST ARGS &ENVIRONMENT ENV)

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.

U7 (&REST ARGS &ENVIRONMENT ENV)

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.

U8 (&REST ARGS &ENVIRONMENT ENV)

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.

U9 (&REST ARGS &ENVIRONMENT ENV)

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.

USER1 (&REST ARGS &ENVIRONMENT ENV)

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.

USER2 (&REST ARGS &ENVIRONMENT ENV)

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.

USER3 (&REST ARGS &ENVIRONMENT ENV)

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.

USER4 (&REST ARGS &ENVIRONMENT ENV)

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.

USER5 (&REST ARGS &ENVIRONMENT ENV)

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.

USER6 (&REST ARGS &ENVIRONMENT ENV)

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.

USER7 (&REST ARGS &ENVIRONMENT ENV)

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.

USER8 (&REST ARGS &ENVIRONMENT ENV)

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.

USER9 (&REST ARGS &ENVIRONMENT ENV)

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.

W (&REST ARGS &ENVIRONMENT ENV)

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.

WARN (&REST ARGS &ENVIRONMENT ENV)

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.

WITH-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

WITH-INDENT ((&OPTIONAL (INDENT '(1+ *LOG-INDENT*))) &BODY BODY)

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

WITH-PACKAGE-HIERARCHY (&BODY BODY)

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

Undocumented

MAKE (&OPTIONAL (ARG NIL ARG-P) &ENVIRONMENT ENV)

MAKE-LOGGER (&OPTIONAL (ARG NIL ARG-P) &ENVIRONMENT ENV)

Private

Undocumented

IN-PACKAGE (STRING-DESIGNATOR)

GENERIC-FUNCTION

Public

CONFIGURE (CONFIGURATOR SOURCE &KEY AUTO-RELOAD &ALLOW-OTHER-KEYS)

Configure the logging system from specified source

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)

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

NAMING-OPTION (PACKAGE OPTION)

Return the automatic logger naming option for the specified package. Valid options are keywords: :CATEGORY-SEPARATOR : String that separates category names, default method returns ":" :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 :EXPR-VALUE-SEPARATOR : A string that separates expression and value printed by (LOG-SEXP). Default is equal sign :EXPR-VALUE-SUFFIX : A string inserted into the format statement after each expression and value pair printed by (LOG-SEXP). Default is " ~:_" (a space followed by conditional newline)

PACKAGE-WRAPPER (PACKAGE CATEGORIES EXPLICIT-P)

Allows packages to optionally massage logger names in their namespace. CATEGORIES will be a list of 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. Default method will prefix the passed category list with the current package shortest nickname. Example: ;; Some package wishes to always wrap their logger names in weird prefix and suffix (defmethod package-wrapper ((pkg (eql *package*)) categories explicit-p) (if explicit-p categories (append '(foo bar) categories '(baz)))) Will result in the macro (MAKE-LOGGER :NAME) returning logger named FOO:BAR:NAME:BAZ

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.

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

VARIABLE

Public

*CONFIGURATIONS-FILE*

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

*MAX-CONFIGURATIONS*

Maximum number of configurations in *CONFIGURATIONS* list

*ROOT-LOGGER*

The one and only root logger

*SAVE-CONFIGURATIONS-TO-FILE*

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

CLASS

Public

CONFIGURATION

Used to remember log levels for a set of loggers

CONFIGURATION-ELEMENT

Holds logger and its log level

CONSOLE-APPENDER

A stream appender that writes messages to *debug-io* stream. The *debug-io* is late-binding, that is its the value of that variable in the thread and at the moment of log message being written. If instead you want an appender that would write log messages to the *debug-io* stream active when appender was created, use FIXED-STREAM-APPENDER 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)

FILE-APPENDER

Appender that writes to a file with a fixed file name

FIXED-STREAM-APPENDER

Appender that writes message to the stream in STREAM slot

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: %[-][<MIN>][.<MAX>]<PATTERN-CHAR>[{<EXTRA-ARG>}...] 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) 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 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 -------------------------------------------------------------------- %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 (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 OS-dependent newline sequence. %& Optional newline, issues FRESH-LINE on the stream %m Actual user log message.

PROPERTY-CONFIGURATOR

Class that holds configurator state while parsing the properties file

SIMPLE-LAYOUT

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

CONDITION

Public

LOG4CL-ERROR (MESSAGE &REST ARGS)

Base class for all LOG4CL errors