The log4cl Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The log4cl Reference Manual

This is the log4cl Reference Manual, version 1.1.3, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:12:34 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Introduction

NOTE - Because of some mishap with QuickLisp, June 2013 QuickLisp distribution pulled the master branch of Log4CL instead of stable branch as intended.

Very few incompatibilities been reported, and it makes no sense to downgrade version that been already available in QuickLisp, therefore QuickLisp will continue to pull the master branch from now on.

The major difference of Log4CL 1.1.x version from 1.0.x is the Emacs/Slime integration module, called Log4Slime. This document is written with assumption that you will have Log4Slime loaded and enabled in Emacs.

Installation

Log4CL is available from QuickLisp. To load it use (ql:quickload :log4cl) command from REPL. Log4Slime is available in QuickLisp since June 2013.

Enabling Log4Slime

(ql:quickload :log4slime)
(log4slime:install)

You should get a message like this:

Wrote ~/quicklisp/log4slime-setup.el

Add the following two statements to your ~/.emacs file
------------------------------------------------------
(load "~/quicklisp/log4slime-setup.el")
(global-log4slime-mode 1)
------------------------------------------------------

Follow the above instructions. The most likely point of failure here may be log4slime.el trying to poke the Lisp side to see if log4slime is loaded, and that for some reason it fails.

If it fails, there should be a message in *Messages* buffer, that looks like this: Unable to load log4slime lisp support: <lisp side condition>

In case you did get the above message and you think you fixed the cause, you can make log4slime try again, by turning M-x global-log4slime-mode off/on a few times

You can verify if log4slime is enabled, by looking for the Log4CL menu on top menubar in REPL and Lisp mode buffers, or by submitting a log statement from REPL and seeing output colorized.

Hello world

(progn
  (log:info "I just ate a ~5f, feeling tired" pi) 
  (when (log:debug)
    (dotimes (sheep 3)
      (log:debug sheep "zzz")))
  (log:warn "doh fell asleep for" (random 10) "minutes"))

Should produce the following output nil

You can notice several things right away.

Changing the log level

You can change the log level with by doing (log:config :debug) from REPL. Alternatively, with Log4Slime enabled in REPL buffer, you can right-click on the cl-user part and change the log level from a popup menu.

nil

There is a slight difference between doing it using above two methods, with log:config command, the level is changed for the ROOT category, but right clicking on the package name, changes the log level only for that package.

To change the ROOT category from Emacs, you can use Log4CL dropdown submenu, or Emacs command log4slime-level-selection which is bound to C-c C-g by default.

After pressing C-c C-g which invokes the log4slime-level-selection command you get the following window.

nil

Pressing "p" to select the package category shows effective log level and allows you to change like so

nil

This concludes the very basic introduction, if you were confused by what various terms such as "category" mean, click on the hyperlink to read more about Log4CL concepts.

Or you can skip the theory and just continue to learn by example.

Automatic category naming

Try putting the from the previous section into a DEFUN instead of a PROGN form like so:

(defun hello ()
  (log:info "I just ate a ~5f, feeling tired" pi) 
  (when (log:debug)
    (dotimes (sheep 3)
      (log:debug sheep "zzz")))
  (log:warn "doh fell asleep for" (random 10) "minutes"))

If you run it now, the output under both SBCL and CCL should look like this.

nil

Right click on the blue function name, allows you to change the log level for that specific function.

That is because Log4CL logging macros, automatically determine the category for logging, based on the context where log statement appears. In above example the function was defined in the package CL-USER and function name was HELLO, so the target category of any logging inside the function, was automatically CL-USER.HELLO

It starts with the package, then function. You can try putting one of the log statements inside of a LABELS or FLET forms, to see what happens.

Also note the farthest to the right in the logging category name, the more specific. The level for "hello" overrides that for "cl-user", which in turn overrides that of the root category.

Naming in source files

For the next few examples, it is recommended that you load the examples come together with Log4CL, by doing (ql:quickload :log4cl-examples)

It should produce the following output:

nil

One thing you should notice, is that source file where function is defined now appears as part of the log message too. Go to the source of "greetings". Before you try to use Slime's famous M-. shortcut, try clicking on blue "greetings" word with a left mouse button.

If everything went better then expected, it should land you at the first log statement of the (defun greetings ()). Cool eh?

Naming in CLOS methods

Quickly browse through naming-examples.lisp. There are a few methods defined, including :after/:around methods, as well as some with EQL specializers.

Run a few of them from REPL, like so:

nil

Log statements inside of methods, are using the category name of the generic function, extended with qualifier, and all non-T specializers.

Try going to the source of the above methods by clicking on them. It should land in the right method, without showing Slime's XREF window.

Note how by changing the level of the foobar you control all the methods, but can override them based on their specializers. Try setting :after category to different levels, to control all the :after methods together.

In addition to playing with methods, try (setf (test.package.one:greetings) "Hey") too.

Context sensitivity

As you browse through source, and are inside of one of the methods, check out the Log4CL dropdown menu. Note that "Defun" submenu changes for each method.

nil

Keyboard level selection

Also try C-c C-g shortcut in the same place. You can configure it not to show the selection window at all, by customizing the log4slime-level-selection-single-key Emacs variable.

After pressing C-c C-g while inside of the method nil

You can change keys for the selecting various levels by doing M-x customize-group RET log4slime RET

Note that keyboard selection ignores the Control key so C-c C-g p u is same as C-c C-g C-p C-u

Resetting the mess

If you had forgotten which levels you set for what, and just want to see which levels are set where.

You can display current logging configuration by doing (log:config) without any arguments, it willdisplay a tree

nil

If you have had set a lot of custom levels, and now need to get rid of them, "Reset Children" menu item will nukes the log level from everything underneath the parent. Doing "Reset Children" on the ROOT category, gets rid of every other log level that was set anywhere. Keyboard equivalent is C-c C-g r

nil

Logging configurations

After setting the log levels of a few methods, try doing (log:save :foo) then messing around.. You can restore the named configuration with (log:restore :foo). Configurations are saved in a file in the home directory, so they survive image restarts

See the Finding needle in a haystack section.

The magic of (LOG:CONFIG)

Section To be written, for now simply see docstring for LOG:CONFIG

Read the docstring and play with options, below are a few examples:

nil

Pattern Layout

Section to be written, for now see docstring for docstring for PATTERN-LAYOUT

Common Practices

Some common recipes.

Log levels for production

Generally log levels INFO and below, are used in normal operations of software, while levels higher then INFO are used by programmers.

By default Log4CL is configured with root category having INFO log level.

Log levels for development

DEBUG is for for informing about detailed steps taken by operations and printing intermediate values.

TRACE is for very detailed debugging, like printing variables inside loops and such.

DEBU1..DEBU9 log levels are numerically around the TRACE and can be used if you need more granularity. One possibility is that (log:expr) macro, can be configured via LOG:PACKAGE-OPTIONS mechanism, to use different log level then DEBUG and can set to use one of the extra levels.

OFF log level is very important counter-part for DEBUG and TRACE. Its used for "narrowing things down in reverse", which is described in the next section

Finding needle in a haystack

Programmers often need to concentrate on a specific area of their software. With traditional non-hierarchical logging system, having a lot of debug sprinkled around the code, flood the programmers with a lot of information they don't need, and makes it hard to find the messages relevant to the problem being debugged.

Because Log4CL is hierarchical, its easy to narrow down the logging, to focus on exactly the right area, by using the following process.

  1. Turn DEBUG on for the root category, or entire package and then run your code through the functionality that you are focusing on. REPL will fill with a lot of debugging output.

  2. Right-click on each message that is not related to a problem, and turn the corresponding category OFF. You can how go wide or narrow, turn off entire packages or source files, or by individual methods, functions or local functions. If you went too far, use Reset children command on the parent category.

    If you use CLOS, use the category hierarchy to your advantage, if for example you think problem relates to before or after method, you can can control logging for all :AFTER methods of generic function by clicking :after category in (<gf name> :after <specializer> ...)

  3. Once you narrowed down the logging to your liking, you can quickly save that configuration of log levels with (LOG:SAVE), and later (may be in a different image, or even different machine) restore it with (LOG:RESTORE), and you can give these saved configuration names, such as (LOG:SAVE :bug-123)

Glossary

Very small glossary of Log4CL concepts

Loggers and categories

Loggers are named singleton objects that form a hierarchy, and are sources of log messages, or more correctly entry points where log message enter the logging system. Each call to a logging macro like (log:debug ...) operates on a specific logger object (See also naming section).

Logger's unique name is called "logger's category", or "category name". Loggers form a hierarchy, based on their category names, where child loggers have their category name prefixed by that of the parent, followed by a dot. So if we have loggers A, A.B, A.B.C and A.B.D then logger A is parent of A.B, which has two children A.B.C and A.B.D - as shown on below diagram. (Note: ROOT logger category name is empty string)

ROOT---A---A.B---A.B.C
             |
             \---A.B.D

Because loggers are singletons, logger category name is usually shortened to just CATEGORY and is used inter-changeably with the word LOGGER; the convention is that thing is "a logger" when talking about actual Lisp object, and "category" otherwise.

Each logger can have a log level threshold, or if its does not have one, it inherits one from its parent. To ensure that for any logger, an effective log level can be determined, the ROOT logger always have a level.

Loggers will only pass through messages, if logger's threshold level is equal or greater verbosity, then log message. For example if in above example logger A is configured with info log level, then (log:warn ...) and (log:info) messages will be passed through, but (log:debug) messages would not.

Appenders

Appenders process log messages by writing them to files, or displaying them on the screen. Appenders attach to a specific logger, and each logger can have many appenders attached.

When a log message passes through a logger that has appenders, they are all called in turn to do appender specific processing, be it writing log message to a file, or a terminal. After all of logger's appenders had processed the message, its passed on to the parent logger.

So log messages inheritance flows in reverse order from the log level one, tricking up from child loggers towards root, with below exception.

Each logger has a property called additivity, which is T by default, which controls the above process. When additivity is NIL, logger is called non-additive and any messages that reach it, will not be passed to the parents.

Usually only root logger, or non non-additive loggers will have any appenders attached to them.

Layouts

When appender decide they want to process the log message, they format the log message by means of a layout. Layout is a separate object, that attaches to each appender, and is responsible for the textual formatting of the message.

So while appender provides and manages any serialization for the stream to write to, the layout is actually formatting the log message into that stream.

Log4CL provides two layouts, SIMPLE-LAYOUT which is well, simple, and a very configurable PATTERN-LAYOUT, which specifies the formatting of log messages by mean of printf/format like control string.

Easiest way to use the pattern layout, is by using LOG:CONFIG command to select between several predefined formats.

Or you can look for list of all supported format documentation for the PATTERN-LAYOUT class. Please note that if you are drafting your own format, that Log4SLime fontification relies on regular expressions and the log messages being in a certain order. If your layout is not a minor modification of an built-in one, the Log4Slime fontification may stop working. You can of course adjust the regular expressions used by Log4Slime to match your own custom layout to compensate.

Log Levels

In Log4CL log levels are numeric constants, in order of increased verbosity:

Effective log level

Effective log level of the logger X is determined as follows.

  1. If logger has level threshold set, then this level is the effective log level.

  2. If logger is not first child of a parent, whose category is same as the package name logger was instantiated from, the effective log level of X is the effective log level of its parent logger.

  3. If logger is first child of a parent P named same as package, and there exists a sibling logger S, with the last part of category name equal to that of a source file logger X was instantiated from, and S has a level threshold set, that level is effective level of logger X

  4. Otherwise effective level of logger X is effective level of its parent.

ROOT logger always has a level threshold set, so above steps always result in a valid log level.

Effective log level is returned by the function (log4cl:effective-log-level LOGGER)

FAQ

I don't see log messages from other threads.

The *TERMINAL-IO* value bound in the other threads is probably different and points
to other place (likely *inferior-lisp* buffer under Slime)

  1. (log:config :sane2) will copy messages from other threads to REPL while continuing output to thread specific *TERMINAL-IO* (REPL thread will still only log to REPL)

  2. (log:config :sane :this-console) will redirect all logging to current console regardless of thread local values of *TERMINAL-IO*

Why Log4CL starts its own thread, and how I get rid of it

Its a flusher thread to flush the appenders, it increases performance greatly when there is a lot of logging.oe

You can stop it by calling (log4cl:stop-hierarchy-watcher-thread)

On SBCL Log4CL uses *EXIT-HOOKS* and *SAVE-HOOKS* to automatically flush all appenders on exit, so that last second of logging is not lost, and to terminate the watcher thread when saving image, which can't be done with multiple threads running.

I'd like just the log messages, and not all the extra stuff

Use pattern layout with just %m%n format (message + newline)

How do I log into a file

(log:config :daily "file.txt") which will be backed up each day to file.txt.YYYYMMDD

I want both log file and backup log file to have YYYYMMDD prefix or roll once per week

(log:config :daily "file.txt.%Y%m%d") file will roll when %Y%m%d expansion changes.

What about just one plain file, without rolling

(log:config :daily "file.txt" :backup nil)


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 log4cl

Version

1.1.3

Dependencies
Source

log4cl.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

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


Previous: , Up: Modules   [Contents][Index]

3.1 log4cl/src

Parent

log4cl (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

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


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 log4cl.asd

Location

log4cl.asd

Systems

log4cl (system)

Packages

log4cl.system


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 log4cl/src/impl-package.lisp

Parent

src (module)

Location

src/impl-package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 log4cl/src/defs.lisp

Dependency

impl-package.lisp (file)

Parent

src (module)

Location

src/defs.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 log4cl/src/naming.lisp

Dependency

defs.lisp (file)

Parent

src (module)

Location

src/naming.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 log4cl/src/naming-sbcl.lisp

Dependency

naming.lisp (file)

Parent

src (module)

Location

src/naming-sbcl.lisp

Exported Definitions

enclosing-scope-block-name (method)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 log4cl/src/appender-base.lisp

Dependency

naming-sbcl.lisp (file)

Parent

src (module)

Location

src/appender-base.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 log4cl/src/hierarchy-base.lisp

Dependency

appender-base.lisp (file)

Parent

src (module)

Location

src/hierarchy-base.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 log4cl/src/hierarchy.lisp

Dependency

hierarchy-base.lisp (file)

Parent

src (module)

Location

src/hierarchy.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 log4cl/src/logger.lisp

Dependency

hierarchy.lisp (file)

Parent

src (module)

Location

src/logger.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 log4cl/src/logging-macros.lisp

Dependency

logger.lisp (file)

Parent

src (module)

Location

src/logging-macros.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 log4cl/src/self-logger.lisp

Dependency

logging-macros.lisp (file)

Parent

src (module)

Location

src/self-logger.lisp

Exported Definitions
Internal Definitions

*self-log-config* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 log4cl/src/layout.lisp

Dependency

self-logger.lisp (file)

Parent

src (module)

Location

src/layout.lisp

Exported Definitions
Internal Definitions

property-alist (method)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 log4cl/src/simple-layout.lisp

Dependency

layout.lisp (file)

Parent

src (module)

Location

src/simple-layout.lisp

Exported Definitions
Internal Definitions

write-log-level (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 log4cl/src/pattern-layout.lisp

Dependency

simple-layout.lisp (file)

Parent

src (module)

Location

src/pattern-layout.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.15 log4cl/src/appender.lisp

Dependency

pattern-layout.lisp (file)

Parent

src (module)

Location

src/appender.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.16 log4cl/src/watcher.lisp

Dependency

appender.lisp (file)

Parent

src (module)

Location

src/watcher.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.17 log4cl/src/configurator.lisp

Dependency

watcher.lisp (file)

Parent

src (module)

Location

src/configurator.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.18 log4cl/src/property-parser.lisp

Dependency

configurator.lisp (file)

Parent

src (module)

Location

src/property-parser.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.19 log4cl/src/property-configurator.lisp

Dependency

property-parser.lisp (file)

Parent

src (module)

Location

src/property-configurator.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.20 log4cl/src/package.lisp

Dependency

property-configurator.lisp (file)

Parent

src (module)

Location

src/package.lisp

Packages

log

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 log4cl.system

Source

log4cl.asd

Use List

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 log4cl-impl

Source

impl-package.lisp (file)

Nickname

log4cl

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 log4cl-impl-fixer

Source

impl-package.lisp (file)

Use List

common-lisp


Previous: , Up: Packages   [Contents][Index]

5.4 log

Source

package.lisp (file)

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Constants

Constant: +log-level-debu1+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu2+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu3+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu4+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu5+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu6+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu7+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu8+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debu9+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-debug+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-error+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-fatal+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-info+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-off+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-trace+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-unset+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +log-level-warn+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +max-log-level+
Package

log4cl-impl

Source

defs.lisp (file)

Constant: +min-log-level+
Package

log4cl-impl

Source

defs.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

Special Variable: *default-naming-configuration*

Default naming configuration

Package

log4cl-impl

Source

naming.lisp (file)

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 (file)

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 (file)

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 (file)

Special Variable: *max-configurations*

Maximum number of configurations in *CONFIGURATIONS* list

Package

log4cl-impl

Source

configurator.lisp (file)

Special Variable: *naming-configuration*

Naming configuration currently in effect

Package

log4cl-impl

Source

naming.lisp (file)

Special Variable: *ndc-context*

Value that is printed by %x pattern format

Package

log4cl-impl

Source

defs.lisp (file)

Special Variable: *root-logger*

The one and only root logger

Package

log4cl-impl

Source

logger.lisp (file)

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

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

Package

log4cl-impl

Source

configurator.lisp (file)

Special Variable: +expr-format-fancy+
Package

log4cl-impl

Source

naming.lisp (file)

Special Variable: +expr-format-simple+
Package

log4cl-impl

Source

naming.lisp (file)

Special Variable: +self-logger+
Package

log4cl-impl

Source

self-logger.lisp (file)

Special Variable: +self-meta-logger+
Package

log4cl-impl

Source

self-logger.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Macros

Macro: category &optional ARG
Package

log

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

Macro: in-hierarchy &rest ARGS

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

Package

log

Source

package.lisp (file)

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 (file)

Macro: in-package-hierarchy &rest ARGS

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

Package

log

Source

package.lisp (file)

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 (file)

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

Source

logging-macros.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Macro: make &rest ARGS
Package

log

Source

package.lisp (file)

Macro: make-logger &optional ARG
Package

log4cl-impl

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

Macro: 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

log

Source

package.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

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

Source

logging-macros.lisp (file)

Macro: with-hierarchy &rest ARGS

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

Package

log

Source

package.lisp (file)

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

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

Package

log

Source

logging-macros.lisp (file)

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 (file)

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 (file)

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 (file)

Macro: with-ndc-context &rest ARGS

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

Package

log4cl-impl

Source

package.lisp (file)

Macro: with-package-hierarchy &rest ARGS

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

Package

log

Source

package.lisp (file)

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 (file)

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

log4cl-impl

Source

naming.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 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 (file)

Function: add-appender LOGGER APPENDER

Adds appender to the logger

Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Function: all-appenders &optional ALL-HIERARCHIES

Return all existing appenders in all hierarchies

Package

log4cl-impl

Source

watcher.lisp (file)

Function: all-configurations ()

Returns the *CONFIGURATIONS* list

Package

log4cl-impl

Source

configurator.lisp (file)

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

Source

configurator.lisp (file)

Function: category-case &optional NC
Package

log4cl-impl

Source

naming.lisp (file)

Function: category-separator &optional NC
Package

log4cl-impl

Source

naming.lisp (file)

Function: clear-logging-configuration ()

Delete all loggers configuration, leaving only LOG4CL-IMPL

Package

log4cl-impl

Source

configurator.lisp (file)

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

Source

configurator.lisp (file)

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 (file)

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 (file)

Function: expr-print-format &optional NC
Package

log4cl-impl

Source

naming.lisp (file)

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 (file)

Function: flush-all-appenders &optional ALL-HIERARCHIES

Flush any appenders that had output since being flushed

Package

log4cl-impl

Source

appender.lisp (file)

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 (file)

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 (file)

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 (file)

Function: join-categories SEPARATOR LIST

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

Package

log4cl-impl

Source

naming.lisp (file)

Function: list-configurations &optional STREAM

Prints the *CONFIGURATIONS* list

Package

log4cl-impl

Source

configurator.lisp (file)

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 (file)

Function: log-level-to-string LEVEL

Return log-level string for the level

Package

log4cl-impl

Source

logger.lisp (file)

Function: log4cl-error MESSAGE &rest ARGS
Package

log4cl-impl

Source

defs.lisp (file)

Function: logger-additivity LOGGER

Return logger additivity

Package

log4cl-impl

Source

logger.lisp (file)

Writer

(setf logger-additivity) (function)

Function: (setf logger-additivity) ADDITIVITY LOGGER

Set logger appender additivity. Returns new additivity

Package

log4cl-impl

Source

logger.lisp (file)

Reader

logger-additivity (function)

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 (file)

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 (file)

Function: logger-categories LOGGER

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

Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-category LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-children LOGGER

Return a freshly consed list of LOGGER’s direct children

Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-depth LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Function: logger-file LOGGER

Return source file pathname where logger was instantiated

Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-file-logger LOGGER

Return source file pathname where logger was instantiated

Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-file-namestring LOGGER

Return source file name string where logger was instantiated

Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Writer

(setf logger-log-level) (function)

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

Set logger log level. Returns logger own log level

Package

log4cl-impl

Source

logger.lisp (file)

Reader

logger-log-level (function)

Function: logger-name LOGGER

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

Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-parent LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Function: make-package-categories PACKAGE

Return package categories split as per package configuration

Package

log4cl-impl

Source

naming.lisp (file)

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 (file)

Function: map-logger-descendants FUNCTION LOGGER

Apply the function to all of logger’s descendants

Package

log4cl-impl

Source

logger.lisp (file)

Function: old-logging-macros &optional NC
Package

log4cl-impl

Source

naming.lisp (file)

Function: pattern-layout-error MESSAGE &rest ARGS
Package

log4cl-impl

Source

pattern-layout.lisp (file)

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

Source

configurator.lisp (file)

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

Source

configurator.lisp (file)

Function: remove-all-appenders LOGGER

Removes all appenders from the logger.

Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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

log4cl-impl

Source

watcher.lisp (file)

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

log4cl-impl

Source

watcher.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (file)

Methods
Method: appender-added LOGGER (APPENDER stream-appender) after

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

Source

appender.lisp (file)

Method: appender-added LOGGER APPENDER
Source

logger.lisp (file)

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 (file)

Methods
Method: appender-do-append (THIS rolling-file-appender-base) LOGGER LEVEL LOG-FUNC before
Source

appender.lisp (file)

Method: appender-do-append (THIS fixed-stream-appender-base) LOGGER LEVEL LOG-FUNC
Source

appender.lisp (file)

Method: appender-do-append (THIS stream-appender) LOGGER LEVEL LOG-FUNC
Source

appender.lisp (file)

Method: appender-do-append (THIS serialized-appender) LOGGER LEVEL LOG-FUNC around
Source

appender.lisp (file)

Method: appender-do-append (THIS tricky-console-appender) LOGGER LEVEL LOG-FUNC around
Source

appender.lisp (file)

Method: appender-do-append (APPENDER counting-appender) LOGGER LEVEL LOG-FUNC
Source

appender.lisp (file)

Method: appender-do-append (APPENDER counting-appender) LOGGER LEVEL LOG-FUNC before
Source

appender.lisp (file)

Method: appender-do-append (APPENDER appender) LOGGER LEVEL LOG-FUNC around
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 (file)

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 (file)

Method: appender-do-flush APPENDER TIME
Generic Function: appender-enabled-p OBJECT
Generic Function: (setf appender-enabled-p) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-enabled-p) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-error-count OBJECT
Generic Function: (setf appender-error-count) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-error-count) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-filename APPENDER

Returns the appenders file name

Package

log4cl-impl

Source

appender.lisp (file)

Methods
Method: appender-filename (DAILY-FILE-APPENDER daily-file-appender)

automatically generated reader method

Method: appender-filename (FILE-APPENDER file-appender)

automatically generated reader method

Generic Function: appender-ignored-error-count OBJECT
Generic Function: (setf appender-ignored-error-count) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-ignored-error-count) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-last-backup-file APPENDER

Returns the appenders last backup file name

Package

log4cl-impl

Source

appender.lisp (file)

Methods
Method: appender-last-backup-file (DAILY-FILE-APPENDER daily-file-appender)

automatically generated reader method

Generic Function: appender-last-error OBJECT
Generic Function: (setf appender-last-error) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-last-error) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-last-ignored-error OBJECT
Generic Function: (setf appender-last-ignored-error) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-last-ignored-error) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-layout OBJECT
Generic Function: (setf appender-layout) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: appender-layout (APPENDER appender)

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-layout) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-logger-count OBJECT
Generic Function: (setf appender-logger-count) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-logger-count) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-loggers OBJECT
Generic Function: (setf appender-loggers) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: appender-loggers (APPENDER appender)

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-loggers) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-message-count OBJECT
Generic Function: (setf appender-message-count) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-message-count) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: appender-next-backup-file APPENDER

Returns the appenders next backup file name

Package

log4cl-impl

Source

appender.lisp (file)

Methods
Method: appender-next-backup-file (DAILY-FILE-APPENDER daily-file-appender)

automatically generated reader method

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 (file)

Methods
Method: appender-removed LOGGER (APPENDER stream-appender) after

When appender refcount is zero, remove it from watch tokens

Source

appender.lisp (file)

Method: appender-removed LOGGER APPENDER

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

Source

logger.lisp (file)

Generic Function: appender-stream APPENDER

Should return the stream to which appender will write log messages

Package

log4cl-impl

Source

appender.lisp (file)

Writer

(setf appender-stream) (generic function)

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

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

Method: appender-stream (FIXED-STREAM-APPENDER fixed-stream-appender)

automatically generated reader method

Method: appender-stream (FIXED-STREAM-APPENDER-BASE fixed-stream-appender-base)

automatically generated reader method

Generic Function: (setf appender-stream) NEW-VALUE OBJECT
Package

log4cl-impl

Reader

appender-stream (generic function)

Methods
Method: (setf appender-stream) NEW-VALUE (FIXED-STREAM-APPENDER fixed-stream-appender)

automatically generated writer method

Source

appender.lisp (file)

Method: (setf appender-stream) NEW-VALUE (FIXED-STREAM-APPENDER-BASE fixed-stream-appender-base)

automatically generated writer method

Source

appender.lisp (file)

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 (file)

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 (file)

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

appender.lisp (file)

Method: close-appender APPENDER
Source

appender.lisp (file)

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 (file)

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 Function: conversion-pattern OBJECT
Generic Function: (setf conversion-pattern) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: conversion-pattern (PATTERN-LAYOUT pattern-layout)

automatically generated reader method

Source

pattern-layout.lisp (file)

Method: (setf conversion-pattern) NEW-VALUE (PATTERN-LAYOUT pattern-layout)

automatically generated writer method

Source

pattern-layout.lisp (file)

Method: (setf conversion-pattern) PATTERN (LAYOUT pattern-layout) after
Source

pattern-layout.lisp (file)

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 (file)

Methods
Method: enclosing-scope-block-name PACKAGE ENV

Return the enclosing block name suitable for naming a logger

Source

naming-sbcl.lisp (file)

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 (file)

Methods
Method: handle-appender-error (A temp-appender) C
Source

appender.lisp (file)

Method: handle-appender-error APPENDER CONDITION
Source

appender.lisp (file)

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 (file)

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 (file)

Method: layout-to-stream (LAYOUT simple-layout) STREAM LOGGER LEVEL LOG-FUNC

Format the log message with the simple layout

Source

simple-layout.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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

Parse the stream and apply changes to logging configuration

Source

property-configurator.lisp (file)

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

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 (file)

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 (file)

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

appender.lisp (file)

Method: save-appender APPENDER
Source

appender.lisp (file)

Generic Function: temp-appender-error-type OBJECT
Generic Function: (setf temp-appender-error-type) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: temp-appender-error-type (TEMP-APPENDER temp-appender)

automatically generated reader method

Source

appender.lisp (file)

Method: (setf temp-appender-error-type) NEW-VALUE (TEMP-APPENDER temp-appender)

automatically generated writer method

Source

appender.lisp (file)

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 (file)

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 (file)

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

appender.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Conditions

Condition: log4cl-error ()

Base class for all LOG4CL errors

Package

log4cl-impl

Source

defs.lisp (file)

Direct superclasses
  • program-error (condition)
  • simple-error (condition)
Direct subclasses
Condition: pattern-layout-error ()
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Direct superclasses
Condition: property-parser-error ()
Package

log4cl-impl

Source

property-parser.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: condition
Initargs

:condition

Readers

condition-of (generic function)

Writers

(setf condition-of) (generic function)

Slot: line-num
Initargs

:line-num

Readers

line-num-of (generic function)

Writers

(setf line-num-of) (generic function)

Slot: line
Initargs

:line

Readers

line-of (generic function)

Writers

(setf line-of) (generic function)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.7 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 (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: layout
Initargs

:layout

Initform

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

Readers

appender-layout (generic function)

Writers

(setf appender-layout) (generic function)

Slot: logger-count
Type

(integer 0)

Initform

0

Readers

appender-logger-count (generic function)

Writers

(setf appender-logger-count) (generic function)

Slot: loggers
Readers

appender-loggers (generic function)

Writers

(setf appender-loggers) (generic function)

Slot: enabled
Initform

t

Readers

appender-enabled-p (generic function)

Writers

(setf appender-enabled-p) (generic function)

Slot: filter
Initargs

:filter

Readers

appender-filter (generic function)

Writers

(setf appender-filter) (generic function)

Slot: last-error
Readers

appender-last-error (generic function)

Writers

(setf appender-last-error) (generic function)

Slot: last-ignored-error
Readers

appender-last-ignored-error (generic function)

Writers

(setf appender-last-ignored-error) (generic function)

Slot: error-count
Type

(integer 0)

Initform

0

Readers

appender-error-count (generic function)

Writers

(setf appender-error-count) (generic function)

Slot: ignored-error-count
Type

(integer 0)

Initform

0

Readers

appender-ignored-error-count (generic function)

Writers

(setf appender-ignored-error-count) (generic function)

Slot: message-count
Type

(integer 0)

Initform

0

Readers

appender-message-count (generic function)

Writers

(setf appender-message-count) (generic function)

Class: configuration ()

Used to remember log levels for a set of loggers

Package

log4cl-impl

Source

configurator.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • print-object (method)
  • elements-of (method)
  • elements-of (method)
  • name-of (method)
  • name-of (method)
Direct slots
Slot: name
Type

atom

Initargs

:name

Initform

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

Readers

name-of (generic function)

Writers

(setf name-of) (generic function)

Slot: elements
Initargs

:elements

Initform

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

Readers

elements-of (generic function)

Writers

(setf elements-of) (generic function)

Class: configuration-element ()

Holds logger and its log level

Package

log4cl-impl

Source

configurator.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: logger
Type

log4cl-impl::logger

Initargs

:logger

Initform

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

Readers

logger-of (generic function)

Slot: level
Type

keyword

Initargs

:level

Initform

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

Readers

level-of (generic function)

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 (file)

Direct superclasses

stream-appender (class)

Direct methods

appender-stream (method)

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 (file)

Direct superclasses

appender (class)

Direct methods
Direct slots
Slot: count
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 (file)

Direct superclasses

rolling-file-appender-base (class)

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 (generic function)

Slot: %next-backup-name
Readers

appender-next-backup-file (generic function)

Slot: %last-backup-name
Readers

appender-last-backup-file (generic function)

Class: file-appender ()

Appender that writes to a file with a fixed file name

Package

log4cl-impl

Source

appender.lisp (file)

Direct superclasses

file-appender-base (class)

Direct methods
Direct slots
Slot: filename
Initargs

:file

Readers

appender-filename (generic function)

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 (file)

Direct superclasses

fixed-stream-appender-base (class)

Direct subclasses
Direct methods

slot-unbound (method)

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 (file)

Direct superclasses

fixed-stream-appender-base (class)

Direct subclasses

this-console-appender (class)

Direct methods
Direct slots
Slot: stream
Initargs

:stream

Readers

appender-stream (generic function)

Writers

(setf appender-stream) (generic function)

Class: layout ()

Abstract layout class

Package

log4cl-impl

Source

layout.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

property-alist (method)

Class: naming-configuration ()

Contains configuration that affects expansion of logger macros.

Package

log4cl-impl

Source

naming.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: category-separator
Initform

"."

Readers

%category-separator (generic function)

Writers

(setf %category-separator) (generic function)

Slot: category-case
Readers

%category-case (generic function)

Writers

(setf %category-case) (generic function)

Slot: expr-print-format
Initform

log4cl-impl:+expr-format-simple+

Readers

%expr-print-format (generic function)

Writers

(setf %expr-print-format) (generic function)

Slot: use-shortest-nickname
Initargs

:use-shortest-nickname

Readers

%use-shortest-nickname (generic function)

Writers

(setf %use-shortest-nickname) (generic function)

Slot: expr-log-level
Initform

log4cl-impl:+log-level-debug+

Readers

%expr-log-level (generic function)

Writers

(setf %expr-log-level) (generic function)

Slot: old-logging-macros
Readers

%old-logging-macros (generic function)

Writers

(setf %old-logging-macros) (generic function)

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 (file)

Direct superclasses

layout (class)

Direct methods
Direct slots
Slot: %pattern
Initargs

:conversion-pattern

Readers

conversion-pattern (generic function)

Writers

(setf conversion-pattern) (generic function)

Slot: %formatter
Class: property-configurator ()

Class that holds configurator state while parsing the properties file

Package

log4cl-impl

Source

property-configurator.lisp (file)

Direct superclasses

property-parser (class)

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 (file)

Direct superclasses

standard-object (class)

Direct subclasses

property-configurator (class)

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

:separator

Initform

":"

Slot: name-token-read-case
Initargs

:read-case

Initform

(readtable-case *readtable*)

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 (file)

Direct superclasses

file-appender-base (class)

Direct subclasses

daily-file-appender (class)

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

:rollover-check-period

Initform

60

Slot: %next-rollover-time
Initform

0

Class: serialized-appender ()

Appender that serializes itself using a lock

Package

log4cl-impl

Source

appender.lisp (file)

Direct superclasses

appender (class)

Direct subclasses

stream-appender (class)

Direct methods

appender-do-append (method)

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 (file)

Direct superclasses

layout (class)

Direct methods

layout-to-stream (method)

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 (file)

Direct superclasses

serialized-appender (class)

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

:immediate-flush

Slot: flush-interval
Initargs

:flush-interval

Initform

1

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 (file)

Direct superclasses

standard-object (class)

Direct subclasses

this-console-appender (class)

Direct methods
Direct slots
Slot: error-type
Initargs

:error-type

Initform

(quote error)

Readers

temp-appender-error-type (generic function)

Writers

(setf temp-appender-error-type) (generic function)

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 (file)

Direct superclasses
Direct subclasses

tricky-console-appender (class)

Direct methods

shared-initialize (method)

Direct slots
Slot: stream
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 (file)

Direct superclasses

this-console-appender (class)

Direct methods

appender-do-append (method)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Constants

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

log4cl-impl

Source

defs.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

Constant: package-ref-sym
Package

log4cl-impl

Source

logger.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Special variables

Special Variable: %parse-line

Current line being parsed

Package

log4cl-impl

Source

property-parser.lisp (file)

Special Variable: %parse-line-num

Current line number in the input stream

Package

log4cl-impl

Source

property-parser.lisp (file)

Special Variable: *configurations*

List of all LOGGER-CONFIGURATION objects

Package

log4cl-impl

Source

configurator.lisp (file)

Special Variable: *default-patterns*
Package

log4cl-impl

Source

configurator.lisp (file)

Special Variable: *dotted-naming-configuration*

Naming configuration for dotted packages

Package

log4cl-impl

Source

naming.lisp (file)

Special Variable: *formatters*
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Special Variable: *hierarchies*

Array of all hierarchies in the system

Package

log4cl-impl

Source

hierarchy-base.lisp (file)

Special Variable: *hierarchy-lock*

Global lock for changing logging configuration

Package

log4cl-impl

Source

hierarchy-base.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

Special Variable: *log-event-time*

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

Package

log4cl-impl

Source

defs.lisp (file)

Special Variable: *name-to-hierarchy*

EQL hash table mapping hierarchy identifier to hierarchy index

Package

log4cl-impl

Source

hierarchy-base.lisp (file)

Special Variable: *naming-configurations*
Package

log4cl-impl

Source

naming.lisp (file)

Special Variable: *self-log-config*
Package

log4cl-impl

Source

self-logger.lisp (file)

Special Variable: *stop-cv*
Package

log4cl-impl

Source

watcher.lisp (file)

Special Variable: *stop-lock*
Package

log4cl-impl

Source

watcher.lisp (file)

Special Variable: *stop-watcher*
Package

log4cl-impl

Source

watcher.lisp (file)

Special Variable: *watcher-event-time*

Universal time of the current watcher heartbeat

Package

log4cl-impl

Source

hierarchy-base.lisp (file)

Special Variable: *watcher-thread*

The hierarchy watcher thread

Package

log4cl-impl

Source

hierarchy-base.lisp (file)

Special Variable: *watcher-thread-bindings*

Extra bindings for watcher thread

Package

log4cl-impl

Source

watcher.lisp (file)

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

log4cl-impl

Source

pattern-layout.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

Special Variable: +log-level-symbols+
Package

log4cl-impl

Source

defs.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

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

log4cl-impl

Source

defs.lisp (file)

Special Variable: +make-logger-symbols+
Package

log4cl-impl

Source

logging-macros.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Macros

Macro: %allow-with-interrupts &body BODY
Package

log4cl-impl

Source

watcher.lisp (file)

Macro: %with-local-interrupts &body BODY
Package

log4cl-impl

Source

watcher.lisp (file)

Macro: %without-interrupts &body BODY
Package

log4cl-impl

Source

watcher.lisp (file)

Macro: define-category-depth-accessor NAME1 NAME2 NUM
Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Macro: deflog-macros LEVELS
Package

log4cl-impl

Source

logging-macros.lisp (file)

Macro: deflog-sexp-macros LEVELS
Package

log4cl-impl

Source

logging-macros.lisp (file)

Macro: forward-function NAME FROM-NAME
Package

log4cl-impl

Source

package.lisp (file)

Macro: forward-levels LEVELS
Package

log4cl-impl

Source

package.lisp (file)

Macro: forward-macro NAME FROM-NAME &optional DEPRECATE REPLACEMENT
Package

log4cl-impl

Source

package.lisp (file)

Macro: forward-sexp-levels LEVELS
Package

log4cl-impl

Source

package.lisp (file)

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 (file)

Macro: with-hierarchies-lock &body BODY
Package

log4cl-impl

Source

hierarchy.lisp (file)

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

log4cl-impl

Source

hierarchy.lisp (file)

Macro: with-logged-problems CONTEXT &body BODY
Package

log4cl-impl

Source

watcher.lisp (file)

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 (file)

Macro: with-small-dynamic-extent-vector (NAME LEN LEN-EXPR &optional LIMIT) &body BODY
Package

log4cl-impl

Source

pattern-layout.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Functions

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

log4cl-impl

Source

logger.lisp (file)

Function: %create-root-logger &key (CATEGORY CATEGORY) (CATEGORY-SEPARATOR CATEGORY-SEPARATOR) (NAME-START-POS NAME-START-POS) (PARENT PARENT) (DEPTH DEPTH) (CHILD-HASH CHILD-HASH) (STATE STATE) (DUMMY DUMMY)
Package

log4cl-impl

Source

logger.lisp (file)

Function: %hierarchy-index NAME
Package

log4cl-impl

Source

hierarchy.lisp (file)

Function: %logger-category INSTANCE
Function: (setf %logger-category) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: %logger-category-separator INSTANCE
Function: (setf %logger-category-separator) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: %logger-child-hash INSTANCE
Function: (setf %logger-child-hash) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: %logger-depth INSTANCE
Function: (setf %logger-depth) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: %logger-name-start-pos INSTANCE
Function: (setf %logger-name-start-pos) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: %logger-parent INSTANCE
Function: (setf %logger-parent) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: %logger-state INSTANCE
Function: (setf %logger-state) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Function: add-appender-internal LOGGER APPENDER &optional ADJUST-P
Package

log4cl-impl

Source

logger.lisp (file)

Function: adjust-all-loggers-state NEW-LEN
Package

log4cl-impl

Source

logger.lisp (file)

Function: adjust-logger LOGGER

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

Package

log4cl-impl

Source

logger.lisp (file)

Function: adjusted-logger-depth LOGGER
Package

log4cl-impl

Source

pattern-layout.lisp (file)

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 (file)

Function: apply-logging-configuration CNF

Restores logging configuration

Package

log4cl-impl

Source

configurator.lisp (file)

Function: auto-named-p CNF

Test if logging configuration name was auto-generated

Package

log4cl-impl

Source

configurator.lisp (file)

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 (file)

Function: call-with-logged-problems CONTEXT THUNK
Package

log4cl-impl

Source

watcher.lisp (file)

Function: check-arg NAME VALUE
Package

log4cl-impl

Source

defs.lisp (file)

Function: compile-pattern LAYOUT PATTERN
Package

log4cl-impl

Source

pattern-layout.lisp (file)

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 (file)

Function: convert-read-case STRING CASE

Convert STRING according to CASE

Package

log4cl-impl

Source

property-parser.lisp (file)

Function: copy-file-logger INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: copy-logger INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: copy-logger-state INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: copy-root-logger INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: copy-source-file-logger INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: create-appender-file APPENDER
Package

log4cl-impl

Source

appender.lisp (file)

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 (file)

Function: create-file-logger &key (CATEGORY CATEGORY) (CATEGORY-SEPARATOR CATEGORY-SEPARATOR) (NAME-START-POS NAME-START-POS) (PARENT PARENT) (DEPTH DEPTH) (CHILD-HASH CHILD-HASH) (STATE STATE) (FILE FILE)
Package

log4cl-impl

Source

logger.lisp (file)

Function: create-logger &key (CATEGORY CATEGORY) (CATEGORY-SEPARATOR CATEGORY-SEPARATOR) (NAME-START-POS NAME-START-POS) (PARENT PARENT) (DEPTH DEPTH) (CHILD-HASH CHILD-HASH) (STATE STATE)
Package

log4cl-impl

Source

logger.lisp (file)

Function: create-source-file-logger &key (CATEGORY CATEGORY) (CATEGORY-SEPARATOR CATEGORY-SEPARATOR) (NAME-START-POS NAME-START-POS) (PARENT PARENT) (DEPTH DEPTH) (CHILD-HASH CHILD-HASH) (STATE STATE) (FILE FILE) (NAMESTRING NAMESTRING)
Package

log4cl-impl

Source

logger.lisp (file)

Function: current-hierarchy ()

Return the currently active hierarchy

Package

log4cl-impl

Source

hierarchy.lisp (file)

Function: current-state LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: dotted-package-p PACKAGE
Package

log4cl-impl

Source

naming.lisp (file)

Function: ensure-naming-configuration PACKAGE
Package

log4cl-impl

Source

naming.lisp (file)

Function: exit-hook ()

Flushes all existing appenders

Package

log4cl-impl

Source

watcher.lisp (file)

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 (file)

Function: expand-name-format PATTERN TIME UTC-P
Package

log4cl-impl

Source

appender.lisp (file)

Function: expr-log-level &optional NC
Package

log4cl-impl

Source

naming.lisp (file)

Function: figure-out-pattern &rest ARGS
Package

log4cl-impl

Source

configurator.lisp (file)

Function: file-logger-category INSTANCE
Function: (setf file-logger-category) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-category-separator INSTANCE
Function: (setf file-logger-category-separator) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-child-hash INSTANCE
Function: (setf file-logger-child-hash) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-depth INSTANCE
Function: (setf file-logger-depth) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-file INSTANCE
Function: (setf file-logger-file) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

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

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-p OBJECT
Package

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-parent INSTANCE
Function: (setf file-logger-parent) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: file-logger-state INSTANCE
Function: (setf file-logger-state) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: find-or-create-naming-configuration P &optional CREATEP
Package

log4cl-impl

Source

naming.lisp (file)

Function: format-categories STREAM FMT-INFO CATS NUM-CATS SEPARATOR
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Function: format-categories-range STREAM FMT-INFO LOGGER START-DEPTH END-DEPTH
Package

log4cl-impl

Source

pattern-layout.lisp (file)

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 (file)

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 (file)

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

Source

logger.lisp (file)

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 (file)

Function: hierarchy-watcher-do-one-token HIER TOKEN
Package

log4cl-impl

Source

watcher.lisp (file)

Function: hierarchy-watcher-once ()

Do one iteration of watcher loop.

Package

log4cl-impl

Source

watcher.lisp (file)

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 (file)

Function: init-hook ()

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

Package

log4cl-impl

Source

watcher.lisp (file)

Function: instantiate-logger PACKAGE CATEGORIES EXPLICITP CREATEP
Package

log4cl-impl

Source

naming.lisp (file)

Function: intern-boolean VALUE

Parse boolean value

Package

log4cl-impl

Source

property-configurator.lisp (file)

Function: intern-class-name STRING
Package

log4cl-impl

Source

property-configurator.lisp (file)

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 (file)

Function: kw= ARG WHAT
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Function: log-appender-disabled APPENDER CONDITION
Package

log4cl-impl

Source

appender.lisp (file)

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 (file)

Function: log-event-time ()

Returns the universal time of the current log event

Package

log4cl-impl

Source

logger.lisp (file)

Function: log-level-to-lc-string LEVEL

Return lower case log-level string for the level

Package

log4cl-impl

Source

logger.lisp (file)

Function: log-with-logger LOGGER LEVEL LOG-FUNC PACKAGE

Submit message to logger appenders, and its parent logger

Package

log4cl-impl

Source

logger.lisp (file)

Function: log4cl-style-warning MESSAGE &rest ARGS
Package

log4cl-impl

Source

defs.lisp (file)

Function: logger-category-separator LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-child-hash LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-first-after-package-p LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-flags-depth FLAGS
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-flags-pkg-idx-end FLAGS
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-flags-pkg-idx-start FLAGS
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-name-length LOGGER

Return length of logger itself (without parent loggers)

Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-name-start-pos LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-p OBJECT
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-pkg-idx-end LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-pkg-idx-start LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-state LOGGER
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-state-additivity INSTANCE
Function: (setf logger-state-additivity) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-state-appenders INSTANCE
Function: (setf logger-state-appenders) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-state-level INSTANCE
Function: (setf logger-state-level) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-state-mask INSTANCE
Function: (setf logger-state-mask) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: logger-state-p OBJECT
Package

log4cl-impl

Source

logger.lisp (file)

Function: make-autosave-configuration ()
Package

log4cl-impl

Source

configurator.lisp (file)

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 (file)

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 (file)

Function: make-logger-flags DEPTH &optional PKG-IDX-START PKG-IDX-END
Package

log4cl-impl

Source

logger.lisp (file)

Function: make-logger-state &key (APPENDERS APPENDERS) (LEVEL LEVEL) (ADDITIVITY ADDITIVITY) (MASK MASK)
Package

log4cl-impl

Source

logger.lisp (file)

Function: maybe-close-stream APPENDER
Package

log4cl-impl

Source

appender.lisp (file)

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 (file)

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 (file)

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

log4cl-impl

Source

watcher.lisp (file)

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 (file)

Function: parse-category-extra-args FMT-INFO CHAR PATTERN START
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Function: parse-category-precision STRING
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Function: parse-date-format-extra-args FMT-INFO UTC-P PATTERN START
Package

log4cl-impl

Source

pattern-layout.lisp (file)

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 (file)

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 (file)

Function: perform-default-init ()
Package

log4cl-impl

Source

configurator.lisp (file)

Function: read-configurations-from-file &optional FILE
Package

log4cl-impl

Source

configurator.lisp (file)

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 (file)

Function: remove-all-appenders-internal LOGGER &optional ADJUST-P
Package

log4cl-impl

Source

logger.lisp (file)

Function: remove-appender-internal LOGGER APPENDER &optional ADJUST-P
Package

log4cl-impl

Source

logger.lisp (file)

Function: replace-in-string S X Y
Package

log4cl-impl

Source

configurator.lisp (file)

Function: resolve-stream STREAM

Dereference synonym streams

Package

log4cl-impl

Source

appender.lisp (file)

Function: root-logger-category INSTANCE
Function: (setf root-logger-category) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-category-separator INSTANCE
Function: (setf root-logger-category-separator) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-child-hash INSTANCE
Function: (setf root-logger-child-hash) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-depth INSTANCE
Function: (setf root-logger-depth) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-dummy INSTANCE
Function: (setf root-logger-dummy) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

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

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-p OBJECT
Package

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-parent INSTANCE
Function: (setf root-logger-parent) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: root-logger-state INSTANCE
Function: (setf root-logger-state) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: safe-intern NAME
Package

log4cl-impl

Source

naming-sbcl.lisp (file)

Function: save-all-appenders &optional ALL-HIERARCHIES

Flush any appenders that had output since being flushed

Package

log4cl-impl

Source

appender.lisp (file)

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 (file)

Function: save-configurations-to-file &optional FILE
Package

log4cl-impl

Source

configurator.lisp (file)

Function: save-hook ()

Flushes all existing appenders, and stops watcher thread

Package

log4cl-impl

Source

watcher.lisp (file)

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 (file)

Function: set-additivity LOGGER ADDITIVITY &optional ADJUST-P

Set logger additivity.

Package

log4cl-impl

Source

logger.lisp (file)

Function: set-delayed-instance-class INSTANCE VALUE
Package

log4cl-impl

Source

property-configurator.lisp (file)

Function: set-delayed-instance-property INSTANCE TOKENS VALUE
Package

log4cl-impl

Source

property-configurator.lisp (file)

Function: shortest-package-name PACKAGE

Return the shortest name or nickname of the package

Package

log4cl-impl

Source

naming.lisp (file)

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 (file)

Function: simple-format-catogories STREAM FMT-INFO LOGGER START-DEPTH END-DEPTH
Package

log4cl-impl

Source

pattern-layout.lisp (file)

Function: source-file-logger-category INSTANCE
Function: (setf source-file-logger-category) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

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

log4cl-impl

Source

logger.lisp (file)

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

log4cl-impl

Source

logger.lisp (file)

Function: source-file-logger-depth INSTANCE
Function: (setf source-file-logger-depth) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: source-file-logger-file INSTANCE
Function: (setf source-file-logger-file) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

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

log4cl-impl

Source

logger.lisp (file)

Function: source-file-logger-namestring INSTANCE
Function: (setf source-file-logger-namestring) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: source-file-logger-p OBJECT
Package

log4cl-impl

Source

logger.lisp (file)

Function: source-file-logger-parent INSTANCE
Function: (setf source-file-logger-parent) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

Function: source-file-logger-state INSTANCE
Function: (setf source-file-logger-state) VALUE INSTANCE
Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

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 (file)

Function: start/stop-watcher-hook CMD &optional ARG
Package

log4cl-impl

Source

watcher.lisp (file)

Function: strip-whitespace STRING

Strip tab and space characters from a string

Package

log4cl-impl

Source

logger.lisp (file)

Function: substr SEQ START &optional END
Package

log4cl-impl

Source

logger.lisp (file)

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 (file)

Function: use-shortest-nickname &optional NC
Package

log4cl-impl

Source

naming.lisp (file)

Function: write-log-level LEVEL STREAM

Print the log LEVEL’s name to the STREAM

Package

log4cl-impl

Source

simple-layout.lisp (file)

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 (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Generic functions

Generic Function: %category-case OBJECT
Generic Function: (setf %category-case) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: %category-case (NAMING-CONFIGURATION naming-configuration)

automatically generated reader method

Source

naming.lisp (file)

Method: (setf %category-case) NEW-VALUE (NAMING-CONFIGURATION naming-configuration)

automatically generated writer method

Source

naming.lisp (file)

Generic Function: %category-separator OBJECT
Generic Function: (setf %category-separator) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: %category-separator (NAMING-CONFIGURATION naming-configuration)

automatically generated reader method

Source

naming.lisp (file)

Method: (setf %category-separator) NEW-VALUE (NAMING-CONFIGURATION naming-configuration)

automatically generated writer method

Source

naming.lisp (file)

Generic Function: %expr-log-level OBJECT
Generic Function: (setf %expr-log-level) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

naming.lisp (file)

Method: (setf %expr-log-level) NEW-VALUE (NAMING-CONFIGURATION naming-configuration)

automatically generated writer method

Source

naming.lisp (file)

Generic Function: %expr-print-format OBJECT
Generic Function: (setf %expr-print-format) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

naming.lisp (file)

Method: (setf %expr-print-format) NEW-VALUE (NAMING-CONFIGURATION naming-configuration)

automatically generated writer method

Source

naming.lisp (file)

Generic Function: %old-logging-macros OBJECT
Generic Function: (setf %old-logging-macros) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

naming.lisp (file)

Method: (setf %old-logging-macros) NEW-VALUE (NAMING-CONFIGURATION naming-configuration)

automatically generated writer method

Source

naming.lisp (file)

Generic Function: %use-shortest-nickname OBJECT
Generic Function: (setf %use-shortest-nickname) NEW-VALUE OBJECT
Package

log4cl-impl

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

automatically generated reader method

Source

naming.lisp (file)

Method: (setf %use-shortest-nickname) NEW-VALUE (NAMING-CONFIGURATION naming-configuration)

automatically generated writer method

Source

naming.lisp (file)

Generic Function: appender-filter OBJECT
Generic Function: (setf appender-filter) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: appender-filter (APPENDER appender)

automatically generated reader method

Source

appender-base.lisp (file)

Method: (setf appender-filter) NEW-VALUE (APPENDER appender)

automatically generated writer method

Source

appender-base.lisp (file)

Generic Function: condition-of CONDITION
Generic Function: (setf condition-of) NEW-VALUE CONDITION
Package

log4cl-impl

Methods
Method: condition-of (CONDITION property-parser-error)
Method: (setf condition-of) NEW-VALUE (CONDITION property-parser-error)
Source

property-parser.lisp (file)

Generic Function: elements-of OBJECT
Generic Function: (setf elements-of) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: elements-of (CONFIGURATION configuration)

automatically generated reader method

Source

configurator.lisp (file)

Method: (setf elements-of) NEW-VALUE (CONFIGURATION configuration)

automatically generated writer method

Source

configurator.lisp (file)

Generic Function: filespec-of OBJECT
Generic Function: (setf filespec-of) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: filespec-of (PROPERTY-CONFIGURATOR-FILE-WATCH property-configurator-file-watch)

automatically generated reader method

Source

property-configurator.lisp (file)

Method: (setf filespec-of) NEW-VALUE (PROPERTY-CONFIGURATOR-FILE-WATCH property-configurator-file-watch)

automatically generated writer method

Source

property-configurator.lisp (file)

Generic Function: format-at-flag OBJECT
Package

log4cl-impl

Methods
Method: format-at-flag (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-case OBJECT
Package

log4cl-impl

Methods
Method: format-case (PATTERN-CATEGORY-FORMAT-INFO pattern-category-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-colon-flag OBJECT
Package

log4cl-impl

Methods
Method: format-colon-flag (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-conversion-char OBJECT
Package

log4cl-impl

Methods
Method: format-conversion-char (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-date-format OBJECT
Package

log4cl-impl

Methods
Method: format-date-format (PATTERN-DATE-FORMAT-INFO pattern-date-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-margin OBJECT
Package

log4cl-impl

Methods
Method: format-margin (PATTERN-PRETTY-FMT-INFO pattern-pretty-fmt-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-max-len OBJECT
Package

log4cl-impl

Methods
Method: format-max-len (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-min-len OBJECT
Package

log4cl-impl

Methods
Method: format-min-len (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-package OBJECT
Package

log4cl-impl

Methods
Method: format-package (PATTERN-PRETTY-FMT-INFO pattern-pretty-fmt-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-precision OBJECT
Package

log4cl-impl

Methods
Method: format-precision (PATTERN-CATEGORY-FORMAT-INFO pattern-category-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-prefix OBJECT
Package

log4cl-impl

Methods
Method: format-prefix (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-pretty OBJECT
Package

log4cl-impl

Methods
Method: format-pretty (PATTERN-PRETTY-FMT-INFO pattern-pretty-fmt-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-right-justify OBJECT
Package

log4cl-impl

Methods
Method: format-right-justify (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-separator OBJECT
Package

log4cl-impl

Methods
Method: format-separator (PATTERN-CATEGORY-FORMAT-INFO pattern-category-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-start OBJECT
Package

log4cl-impl

Methods
Method: format-start (PATTERN-CATEGORY-FORMAT-INFO pattern-category-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-suffix OBJECT
Package

log4cl-impl

Methods
Method: format-suffix (FORMAT-INFO format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

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 (file)

Methods
Method: format-time STREAM PATTERN UT UTC-P
Generic Function: format-universal-time OBJECT
Package

log4cl-impl

Methods
Method: format-universal-time (PATTERN-DATE-FORMAT-INFO pattern-date-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: format-utc-p OBJECT
Package

log4cl-impl

Methods
Method: format-utc-p (PATTERN-DATE-FORMAT-INFO pattern-date-format-info)

automatically generated reader method

Source

pattern-layout.lisp (file)

Generic Function: level-of OBJECT
Package

log4cl-impl

Methods
Method: level-of (CONFIGURATION-ELEMENT configuration-element)

automatically generated reader method

Source

configurator.lisp (file)

Generic Function: line-num-of CONDITION
Generic Function: (setf line-num-of) NEW-VALUE CONDITION
Package

log4cl-impl

Methods
Method: line-num-of (CONDITION property-parser-error)
Method: (setf line-num-of) NEW-VALUE (CONDITION property-parser-error)
Source

property-parser.lisp (file)

Generic Function: line-of CONDITION
Generic Function: (setf line-of) NEW-VALUE CONDITION
Package

log4cl-impl

Methods
Method: line-of (CONDITION property-parser-error)
Method: (setf line-of) NEW-VALUE (CONDITION property-parser-error)
Source

property-parser.lisp (file)

Generic Function: logger-of OBJECT
Package

log4cl-impl

Methods
Method: logger-of (CONFIGURATION-ELEMENT configuration-element)

automatically generated reader method

Source

configurator.lisp (file)

Generic Function: name-of OBJECT
Generic Function: (setf name-of) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: name-of (CONFIGURATION configuration)

automatically generated reader method

Source

configurator.lisp (file)

Method: (setf name-of) NEW-VALUE (CONFIGURATION configuration)

automatically generated writer method

Source

configurator.lisp (file)

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 (file)

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 (file)

Methods
Method: parse-property-keyword (PARSER property-configurator) (KEYWORD (eql appender)) TOKENS VALUE
Source

property-configurator.lisp (file)

Method: parse-property-keyword (PARSER property-configurator) (KEYWORD (eql additivity)) TOKENS VALUE
Source

property-configurator.lisp (file)

Method: parse-property-keyword (PARSER property-configurator) (KEYWORD (eql logger)) TOKENS VALUE
Source

property-configurator.lisp (file)

Method: parse-property-keyword (PARSER property-configurator) (KEYWORD (eql rootlogger)) TOKENS VALUE
Source

property-configurator.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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

appender.lisp (file)

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

appender.lisp (file)

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

appender.lisp (file)

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

appender.lisp (file)

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

appender.lisp (file)

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

appender.lisp (file)

Method: property-alist (INSTANCE appender)

Abstract appender has no properties

Source

appender.lisp (file)

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

pattern-layout.lisp (file)

Method: property-alist (INSTANCE layout)

Abstract layout has no properties

Source

layout.lisp (file)

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 (file)

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 (file)

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 (file)

Methods
Method: resolve-default-logger-form PACKAGE ENV ARGS

Returns the logger named after the enclosing lexical environment

Generic Function: watch-tokens OBJECT
Generic Function: (setf watch-tokens) NEW-VALUE OBJECT
Package

log4cl-impl

Methods
Method: watch-tokens (HIERARCHY hierarchy)

automatically generated reader method

Source

hierarchy-base.lisp (file)

Method: (setf watch-tokens) NEW-VALUE (HIERARCHY hierarchy)

automatically generated writer method

Source

hierarchy-base.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.6 Conditions

Condition: log4cl-style-warning ()
Package

log4cl-impl

Source

defs.lisp (file)

Direct superclasses
  • style-warning (condition)
  • simple-condition (condition)

Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.7 Structures

Structure: file-logger ()
Package

log4cl-impl

Source

logger.lisp (file)

Direct superclasses

logger (structure)

Direct methods

print-object (method)

Direct slots
Slot: file
Type

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

Readers

file-logger-file (function)

Writers

(setf file-logger-file) (function)

Structure: logger ()
Package

log4cl-impl

Source

logger.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods
  • make-load-form (method)
  • print-object (method)
Direct slots
Slot: category
Type

simple-string

Readers

%logger-category (function)

Writers

(setf %logger-category) (function)

Slot: category-separator
Type

simple-string

Readers

%logger-category-separator (function)

Writers

(setf %logger-category-separator) (function)

Slot: name-start-pos
Type

fixnum

Initform

0

Readers

%logger-name-start-pos (function)

Writers

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

Slot: parent
Type

(or null log4cl-impl::logger)

Readers

%logger-parent (function)

Writers

(setf %logger-parent) (function)

Slot: depth
Type

fixnum

Initform

0

Readers

%logger-depth (function)

Writers

(setf %logger-depth) (function)

Slot: child-hash
Type

(or null hash-table)

Readers

%logger-child-hash (function)

Writers

(setf %logger-child-hash) (function)

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 (function)

Writers

(setf %logger-state) (function)

Structure: logger-state ()
Package

log4cl-impl

Source

logger.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: appenders
Type

list

Readers

logger-state-appenders (function)

Writers

(setf logger-state-appenders) (function)

Slot: level
Type

(or null fixnum)

Readers

logger-state-level (function)

Writers

(setf logger-state-level) (function)

Slot: additivity
Type

boolean

Initform

t

Readers

logger-state-additivity (function)

Writers

(setf logger-state-additivity) (function)

Slot: mask
Type

fixnum

Initform

0

Readers

logger-state-mask (function)

Writers

(setf logger-state-mask) (function)

Structure: root-logger ()
Package

log4cl-impl

Source

logger.lisp (file)

Direct superclasses

logger (structure)

Direct slots
Slot: dummy
Readers

root-logger-dummy (function)

Writers

(setf root-logger-dummy) (function)

Structure: source-file-logger ()
Package

log4cl-impl

Source

logger.lisp (file)

Direct superclasses

logger (structure)

Direct methods

print-object (method)

Direct slots
Slot: file
Type

pathname

Readers

source-file-logger-file (function)

Writers

(setf source-file-logger-file) (function)

Slot: namestring
Type

simple-string

Readers

source-file-logger-namestring (function)

Writers

(setf source-file-logger-namestring) (function)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.8 Classes

Class: delayed-appender ()
Package

log4cl-impl

Source

property-configurator.lisp (file)

Direct superclasses

delayed-instance (class)

Direct slots
Slot: layout
Slot: name
Initargs

:name

Slot: used
Class: delayed-instance ()
Package

log4cl-impl

Source

property-configurator.lisp (file)

Direct superclasses

property-location (class)

Direct subclasses
Direct slots
Slot: class
Slot: properties
Slot: extra-initargs
Slot: instance
Class: delayed-layout ()
Package

log4cl-impl

Source

property-configurator.lisp (file)

Direct superclasses

delayed-instance (class)

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 (file)

Direct superclasses

stream-appender (class)

Direct subclasses
Direct methods
Direct slots
Slot: stream
Readers

appender-stream (generic function)

Writers

(setf appender-stream) (generic function)

Slot: stream-owner
Initargs

:stream-owner

Class: format-info ()

Represents data for a single conversion pattern

Package

log4cl-impl

Source

pattern-layout.lisp (file)

Direct superclasses

standard-object (class)

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

character

Initargs

:conversion-char

Readers

format-conversion-char (generic function)

Slot: minlen
Type

fixnum

Initargs

:minlen

Initform

0

Readers

format-min-len (generic function)

Slot: maxlen
Type

(or null fixnum)

Initargs

:maxlen

Readers

format-max-len (generic function)

Slot: right-justify
Type

boolean

Initargs

:right-justify

Readers

format-right-justify (generic function)

Slot: prefix
Type

(or null simple-string)

Initargs

:prefix

Readers

format-prefix (generic function)

Slot: suffix
Type

(or null simple-string)

Initargs

:suffix

Readers

format-suffix (generic function)

Slot: colon-flag
Type

boolean

Initargs

:colon-flag

Readers

format-colon-flag (generic function)

Slot: at-flag
Type

boolean

Initargs

:at-flag

Readers

format-at-flag (generic function)

Class: hierarchy ()
Package

log4cl-impl

Source

hierarchy-base.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Slot: index
Initargs

:index

Slot: watch-tokens
Readers

watch-tokens (generic function)

Writers

(setf watch-tokens) (generic function)

Slot: %lock
Initform

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

Class: logger-record ()
Package

log4cl-impl

Source

property-configurator.lisp (file)

Direct superclasses

property-location (class)

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 (file)

Direct superclasses

format-info (class)

Direct methods
Direct slots
Slot: precision
Initargs

:precision

Readers

format-precision (generic function)

Slot: start
Initargs

:start

Readers

format-start (generic function)

Slot: separator
Initargs

:separator

Readers

format-separator (generic function)

Slot: case
Initargs

:case

Readers

format-case (generic function)

Class: pattern-date-format-info ()

Extra formatting flags for %d and %D patterns

Package

log4cl-impl

Source

pattern-layout.lisp (file)

Direct superclasses

format-info (class)

Direct methods
Direct slots
Slot: date-format
Initargs

:date-format

Readers

format-date-format (generic function)

Slot: universal-time
Initargs

:universal-time

Readers

format-universal-time (generic function)

Slot: utc-p
Initargs

:utc-p

Readers

format-utc-p (generic function)

Class: pattern-hostname-format-info ()

Extra formatting flags for %h pattern

Package

log4cl-impl

Source

pattern-layout.lisp (file)

Direct superclasses

format-info (class)

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 (file)

Direct superclasses

format-info (class)

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 (file)

Direct superclasses

format-info (class)

Direct methods
Direct slots
Slot: pretty
Type

(or null (member :pretty :nopretty))

Initargs

:pretty

Readers

format-pretty (generic function)

Slot: margin
Initargs

:margin

Readers

format-margin (generic function)

Slot: package
Type

(or null (member :package :nopackage))

Initargs

:package

Readers

format-package (generic function)

Class: process-id-fmt-info ()

Caches process-id

Package

log4cl-impl

Source

pattern-layout.lisp (file)

Direct superclasses

format-info (class)

Direct slots
Slot: process-id
Initargs

:process-id

Class: property-configurator-file-watch ()
Package

log4cl-impl

Source

property-configurator.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: filespec
Initargs

:filespec

Readers

filespec-of (generic function)

Writers

(setf filespec-of) (generic function)

Slot: time
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 (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct slots
Slot: line
Initform

log4cl-impl::%parse-line

Slot: line-num
Initform

log4cl-impl::%parse-line-num


Previous: , Up: Internal definitions   [Contents][Index]

6.2.9 Types

Type: logger-cat-idx ()
Package

log4cl-impl

Source

defs.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M  
Index Entry  Section

F
File, Lisp, log4cl.asd: The log4cl<dot>asd file
File, Lisp, log4cl/src/appender-base.lisp: The log4cl/src/appender-base<dot>lisp file
File, Lisp, log4cl/src/appender.lisp: The log4cl/src/appender<dot>lisp file
File, Lisp, log4cl/src/configurator.lisp: The log4cl/src/configurator<dot>lisp file
File, Lisp, log4cl/src/defs.lisp: The log4cl/src/defs<dot>lisp file
File, Lisp, log4cl/src/hierarchy-base.lisp: The log4cl/src/hierarchy-base<dot>lisp file
File, Lisp, log4cl/src/hierarchy.lisp: The log4cl/src/hierarchy<dot>lisp file
File, Lisp, log4cl/src/impl-package.lisp: The log4cl/src/impl-package<dot>lisp file
File, Lisp, log4cl/src/layout.lisp: The log4cl/src/layout<dot>lisp file
File, Lisp, log4cl/src/logger.lisp: The log4cl/src/logger<dot>lisp file
File, Lisp, log4cl/src/logging-macros.lisp: The log4cl/src/logging-macros<dot>lisp file
File, Lisp, log4cl/src/naming-sbcl.lisp: The log4cl/src/naming-sbcl<dot>lisp file
File, Lisp, log4cl/src/naming.lisp: The log4cl/src/naming<dot>lisp file
File, Lisp, log4cl/src/package.lisp: The log4cl/src/package<dot>lisp file
File, Lisp, log4cl/src/pattern-layout.lisp: The log4cl/src/pattern-layout<dot>lisp file
File, Lisp, log4cl/src/property-configurator.lisp: The log4cl/src/property-configurator<dot>lisp file
File, Lisp, log4cl/src/property-parser.lisp: The log4cl/src/property-parser<dot>lisp file
File, Lisp, log4cl/src/self-logger.lisp: The log4cl/src/self-logger<dot>lisp file
File, Lisp, log4cl/src/simple-layout.lisp: The log4cl/src/simple-layout<dot>lisp file
File, Lisp, log4cl/src/watcher.lisp: The log4cl/src/watcher<dot>lisp file

L
Lisp File, log4cl.asd: The log4cl<dot>asd file
Lisp File, log4cl/src/appender-base.lisp: The log4cl/src/appender-base<dot>lisp file
Lisp File, log4cl/src/appender.lisp: The log4cl/src/appender<dot>lisp file
Lisp File, log4cl/src/configurator.lisp: The log4cl/src/configurator<dot>lisp file
Lisp File, log4cl/src/defs.lisp: The log4cl/src/defs<dot>lisp file
Lisp File, log4cl/src/hierarchy-base.lisp: The log4cl/src/hierarchy-base<dot>lisp file
Lisp File, log4cl/src/hierarchy.lisp: The log4cl/src/hierarchy<dot>lisp file
Lisp File, log4cl/src/impl-package.lisp: The log4cl/src/impl-package<dot>lisp file
Lisp File, log4cl/src/layout.lisp: The log4cl/src/layout<dot>lisp file
Lisp File, log4cl/src/logger.lisp: The log4cl/src/logger<dot>lisp file
Lisp File, log4cl/src/logging-macros.lisp: The log4cl/src/logging-macros<dot>lisp file
Lisp File, log4cl/src/naming-sbcl.lisp: The log4cl/src/naming-sbcl<dot>lisp file
Lisp File, log4cl/src/naming.lisp: The log4cl/src/naming<dot>lisp file
Lisp File, log4cl/src/package.lisp: The log4cl/src/package<dot>lisp file
Lisp File, log4cl/src/pattern-layout.lisp: The log4cl/src/pattern-layout<dot>lisp file
Lisp File, log4cl/src/property-configurator.lisp: The log4cl/src/property-configurator<dot>lisp file
Lisp File, log4cl/src/property-parser.lisp: The log4cl/src/property-parser<dot>lisp file
Lisp File, log4cl/src/self-logger.lisp: The log4cl/src/self-logger<dot>lisp file
Lisp File, log4cl/src/simple-layout.lisp: The log4cl/src/simple-layout<dot>lisp file
Lisp File, log4cl/src/watcher.lisp: The log4cl/src/watcher<dot>lisp file
log4cl.asd: The log4cl<dot>asd file
log4cl/src: The log4cl/src module
<