The verbose Reference Manual

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

The verbose Reference Manual

This is the verbose Reference Manual, version 2.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 06:08:38 2022 GMT+0.

Table of Contents


1 Introduction

How To

Load Verbose with ASDF or Quicklisp.

(ql:quickload :verbose)

Since I expect that logging will be a somewhat frequent need, the Verbose package is aliased to the single letter v. Under normal circumstances, Verbose starts itself up automatically after you've loaded it, so you can dive right in and log things.

(v:log :info :intro "Hello!")

You will notice that there are three pieces of information to every log message you send over Verbose. The level at which the message is logged, the category, and finally the message itself. For each of the standard v:*levels*, a shorthand function trace debug info warn error severe fatal exists.

(v:info :intro "Hello again.")

While the bulk of your logging will probably be made up by messages, you can log any kind of object. However, some classes receive special handling for convenience. Namely strings, symbols, functions, and conditions. Strings in reality are format strings, and thus take an arbitrary number of extra arguments.

(v:info :intro "We are ~:[good to go~;not ready yet~]." NIL)

Similarly, symbols are taken as condition or class names and the rest of the arguments are used as class-initargs. This allows you to conveniently construct custom objects for logging.

(v:info :intro 'simple-error :format-control "Aw huckleberry!")

This will also show the special handling for conditions. When a condition object is logged, Verbose also immediately captures the stack at the current point and formats it as a backtrace when printed. You can control how much of a backtrace is shown, but you'll have to consider Dissect's documentation for that. If you don't like this much info for conditions, you can however also entirely disable it by setting *verbose-conditions* to NIL.

Finally, when logging function objects they are simply called with the rest of the arguments.

(v:info :intro #'1+ 1)

Verbose configures itself to only show messages from the info level and up to you at the REPL. You can change this behaviour by setting the v:repl-level to whichever the lowest level you want to see should be.

(v:debug :intro "Snake, this is a stealth mission.")
(setf (v:repl-level) :debug)
(v:debug :intro "Hrnm... stealth...")

Aside from just being useful information, the categories can also be filtered. Normally all categories are allowed through, but you can limit this to only the categories that you want.

(setf (v:repl-categories) (list :woods))
(v:info :city "Lots of car noises")
(v:info :woods "Birds chirping")

But categories can go beyond that still. Categories are actually trees, if you separate each branch by a dot in the name. You can then filter by branch and only allow subbranches through.

(setf (v:repl-categories) (list :woods.cottage))
(v:info :woods "Birds still chirping")
(v:info :woods.cottage "Crashing sounds as a moose runs through")

As you can guess, you can have an arbitrary amount of categories that you want to see at the same time. If you want to see nothing at all, you set the categories to NIL. If you want to see everything, you set it to T. Juggling the category list can be a bit cumbersome like this though, so for convenience there are add-repl-category and remove-repl-category that each take a list of categories to add or remove at once.

(setf (v:repl-categories) T)

Aside from being trees, a message can also carry more than one category at the same time. This allows you to tailor what you want to see even more selectively. You can also stash away the categories you want to use in a variable so that you can easily reference them without having to write them all out, if it happens to become excessive.

(v:info '(:system :core.toolkit) "Deleting everything on disk...")
(defvar *cats* '(:noodles :trophy :keyboard))
(v:info *cats* "Meow.")

Before I get to the last point about categories, it is necessary to talk a bit about how Verbose works internally. In order to be extensible, a very generic backend is used that bases its ideas in pipelines. What we've used so far is one pipe segment that is automatically constructed for use at the REPL. It consists of a level-filter, a category-tree-filter, and a repl-faucet. The first one only accepts messages of the correct level, the second one only those that match the categories, and the last one is responsible for printing the messages out.

Being extensible like this it allows you to construct any form of pipeline you might want that updates, filters, and finally records the messages as you desire. There is one more final piece to Verbose's system to be aware of. When the system is thread-capable, Verbose launches a background thread that is used to process messages. Whenever you call a logging function it puts it onto a queue and notifies the thread to process it. This is necessary in order to make logging from separate threads simultaneously possible without everything ending up as mangled garbage.

If you don't need to use threads in your application or want to log directly from the current thread, bypassing the background thread you can bind or set *process-locally* to T. Otherwise if you want to use the thread, but sometimes need to ensure that messages have been processed, you can make use of v:sync which will block until all queued messages have been processed.

Finally we come to the last feature to do with categories. You can muffle categories locally, preventing messages with matching categories from being processed. This is an important difference to changing the REPL categories in that the message will never reach the pipeline to begin with. In the case of the REPL categories, other pipes may still process the message-- it just isn't printed to the REPL. You should only use muffling if you are absolutely sure that you do not want these messages to be processed at all.

(v:with-muffled-logging (:cars)
  (v:info :pedestrians "Walking")
  (v:info :cars "Honking")
  (v:info '(:cars :pedestrians) "Exist"))

The with-muffled-logging simply binds *muffled-categories*, which is a list of muffled categories or T for everything, just like for the category filter.

When deploying an application the background thread might again cause problems as it is started by default and dumping an image with threads alive is not possible. Thus, you should call stop on *global-controller* before dumping and start after resuming the image. Alternatively you can push :verbose-no-init onto *features* before loading Verbose and then run start manually.

If you are accessing your Lisp image from multiple SLIME instances and the *standard-output* changes, you can use v:output-here to make it pick up the current standard output value again. Similarly, if you want to redirect the REPL output to another stream, you can do so by setting the shared value.

(v:output-here (open #p"~/some-file.log" :direction :output))

However, if you really want to log to a file, you should see the following section for a proper solution.

Customising Verbose

Especially in production environments you'll likely want to do something more than simply logging to the REPL. This is where the aforementioned pipeline system comes in. Verbose offers a couple of standard pipe segments that should be sufficient for most purposes. If you need more than that, see the next section.

What you'll most likely want to do is configure the controller to send messages through a new pipe that will end in a faucet.

(v:define-pipe ()
  (v:rotating-file-faucet :template #p"verbose.log"))

This is the simplest you can get, and sufficient if you just want to dump literally everything to a file. If you want to filter things, you'll need to stick a filter segment before it.

(v:define-pipe ()
  (v:level-filter :level :error)
  (v:rotating-file-faucet :file #p"err.log"))

You can add as many pipes you want, and stick as many filters before each as you like. For cheap "one-time use" filters that need a bit more work than the level-filter and category-filters offer, you can use piping's predicate-filter, which takes a predicate whose return value dictates whether the message should be let through.

(v:define-pipe ()
  (piping:predicate-filter :predicate (lambda (m) (= 0 (local-time:timestamp-hour (v:timestamp m)))))
  (v:rotating-file-faucet :file #p"midnight.log"))

As mentioned before, everything else will need custom segments, which are discussed in the next section.

Extending Verbose

On the most basic level you might want to customise how messages are printed. Since I don't expect there to be any intermediate libraries basing on Verbose, and instead it being usually used in an end-user application, the simplest way to get that done is to simply override the format-message method.

(defmethod v:format-message ((stream stream) (message v:message))
  (format stream "~&~a~%" (v:content message)))

If you don't like replacing code, you can instead subclass message and set it as the default class.

(defclass my-message (v:message) ())

(defmethod v:format-message ((stream stream) (message my-message))
  ..)

(setf v:*default-message-class* 'my-message)

Doing the latter naturally also allows you to add more fields and other shenanigans. However, in order to actually fill those fields you will have to figure out shenanigans of your own, write log functions of your own that call out to log-message with the desired initargs, or replace/extend the standard methods on log to do what you need them to do.

Next you might want to create a filter pipe segment of your own that does more complex, or perhaps configurable filtering. In order to do this you will want to subclass piping:filter and add a method to pass. This method should return a message object --which may or may not be the same as the one it receives-- to be passed along further down the pipeline or NIL if it should get blocked.

(defclass type-filter (piping:filter)
  ((type :initarg :type :initform T :accessor filter-type)))

(defmethod piping:pass ((filter type-filter) thing)
  (when (typep thing (filter-type filter))
    thing))

After adding the filter and a faucet to the pipeline as illustrated above, you'll likely want to get easy access to it again at a later point in order to be able to change its fields. To do this it pays off to give it a name. You can do this by adding a :name field to your define-pipe expression.

(v:define-pipe ()
  (type-filter :name 'type-filter)
  (v:repl-faucet))

After setting the name, you can retrieve your filter with find-place.

(piping:find-place v:*global-controller* 'type-filter)

These very basic functions is pretty much all the magic that Verbose uses internally to provide you convenience functions like repl-level and make-standard-global-controller.

Building custom faucets that output to a database or some other medium that isn't supported by files follows about the same procedure as making a custom filter. You subclass piping:faucet and add a method on pass that does what you need it to do. Then you instantiate your class and add that to the pipeline.

If the logging levels provided by default are not sufficient for you and you'd like to add some or change them, you merely have to manipulate the *levels* variable. It describes the priority as an integer with the associated symbol. Defining new ones is merely a matter of using add-level. If you also would like a convenience function along with the standard levels, you can use define-level for that.

(v:define-level -20 :whisper)
(v:whisper :somewhere "I'm a ghost.")
(v:add-level 100 'scream)
(v:log 'scream :somewhere "AAAA!!!")

Finally, if you need some more serious control over things and perhaps mess with the dispatch logic or something that I cannot really fathom right now, you might want to create your own controller type. A controller needs to implement a couple of methods in order to function. You will most likely be interested in changing pass and controller-loop. The first is responsible for scheduling the message onto the controller or directly executing it if that is not allowed (by *process-locally*) or not possible. The second is responsible for doing whatever the background thread should be doing.

In the default implementation, pass pushes the message onto a queue and then notifies a condition that should awake the controller thread. The controller thread then processes this queue by calling pass on its pipeline (an array) and each object in the queue. There's some more mechanics involved in order to reduce the potential impact for waiting that complicate this, but in essence that's all that happens.

Also relevant might be start and stop which are responsible for setting up and tearing down any background mechanisms, if necessary. In the standard implementation this takes care of creating and shutting down the thread.

Upgrading from Verbose 1.x

Verbose was one of the very early libraries that I've written in my years of lisp. As such it had somewhat poor style, naming ideas, and plans on how to go about things. In an effort to make Verbose more generally useful and easier to approach I decided that it would be in the best interest to drop all the cruft and change things around somewhat liberally. This means that Verbose 2.0 is incompatible with the previous 1.x.

However, fear not. Most of the high-level interface is still the same. Logging works the same, the controller is in the same place and can be reset in the same way. Adding pipes still works as before. Things have mostly changed on the internals side, so if you did not extend or hack verbose extensively, you should be mostly fine.

One thing to note in particular though is that there is no rotating-log-faucet anymore. It has been replaced by the rotating-file-faucet, which no longer works on CRON intervals, but instead on a less-flexible, but easier to manage set of fixed intervals.

Other than that, I hope that the above documentation will serve as a good guide on how to replace the code that I have broken in the process. My apologies if you have been hit by this; I promise not to break things again in the near future.

Also See


2 Systems

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


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

2.1 verbose

A logging framework using the piping library.

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://Shinmera.github.io/verbose/

Source Control

(GIT https://github.com/Shinmera/verbose.git)

Bug Tracker

https://github.com/Shinmera/verbose/issues

License

zlib

Version

2.0.0

Dependencies
  • piping (system).
  • local-time (system).
  • bordeaux-threads (system).
  • dissect (system).
  • documentation-utils (system).
Source

verbose.asd.

Child Components

3 Files

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


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

3.1 Lisp


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

3.1.1 verbose/verbose.asd

Source

verbose.asd.

Parent Component

verbose (system).

ASDF Systems

verbose.


3.1.2 verbose/package.lisp

Source

verbose.asd.

Parent Component

verbose (system).

Packages

verbose.


3.1.3 verbose/toolkit.lisp

Dependency

package.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Internals

3.1.4 verbose/controller.lisp

Dependency

toolkit.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface

3.1.5 verbose/message.lisp

Dependency

controller.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface

3.1.6 verbose/pipes.lisp

Dependency

message.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface

3.1.7 verbose/convenience.lisp

Dependency

pipes.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface

3.1.8 verbose/conditions.lisp

Dependency

convenience.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface
Internals

*verbose-conditions* (special variable).


3.1.9 verbose/muffling.lisp

Dependency

conditions.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface

3.1.10 verbose/sync-request.lisp

Dependency

muffling.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).

Public Interface
Internals

3.1.11 verbose/documentation.lisp

Dependency

sync-request.lisp (file).

Source

verbose.asd.

Parent Component

verbose (system).


4 Packages

Packages are listed by definition order.


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

4.1 verbose

Source

package.lisp.

Nicknames
  • org.shirakumo.verbose
  • v
Use List
  • common-lisp.
  • piping.
Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *default-message-class*

The class designator of the message class to use when logging messages.

Package

verbose.

Source

message.lisp.

Special Variable: *global-controller*

Stores the default controller.

While it is possible to have multiple controllers, there is not much reason to do so. The pipeline system should be flexible enough to bypass the need for multiple controllers. However, you can still instantiate multiple controllers and manage them in whatever way you like. Just make sure to bind this variable to the appropriate one if the function does not accept the controller as an argument directly.

Package

verbose.

Source

controller.lisp.

Special Variable: *levels*

Holds the alist of priorities to level names.

This list must be sorted in ascending order of priorities.

See ADD-LEVEL
See DEFINE-LEVEL

Package

verbose.

Source

message.lisp.

Special Variable: *muffled-categories*

Variable containing a list of categories that should get muffled upon issuing.

If one of the categories is T, all messages are muffled.
When a category is muffled, it is effectively removed from the
message. If a message has no categories whatsoever, it is not
issued.

See WITH-MUFFLED-LOGGING

Package

verbose.

Source

muffling.lisp.

Special Variable: *process-locally*

Whether to process messages in the current thread.

If this is T, then the messages will be shot through the pipeline in the thread whether the log statement is issued. This may be useful on systems where thread support is not necessary, but will most likely be less performant.

If you really do not need to use threads, it is probably a better idea to simply shut down the controller’s thread anyway. You can do this with STOP.

Package

verbose.

Source

controller.lisp.

Special Variable: *timestamp-format*

The format in which timestamps will be formatted for messages.

See LOCAL-TIME:FORMAT-TIMESTRING

Package

verbose.

Source

message.lisp.


5.1.2 Macros

Macro: define-level (priority level &optional name)

Defines a new level by adding it and constructing a helper function.

The helper function will automatically be exported, if its name is in the VERBOSE package (as it is by default).

See ADD-LEVEL

Package

verbose.

Source

message.lisp.

Macro: define-pipe ((&optional pipeline place) &body segments)

Shorthand convenience macro to define new pipes.

SEGMENT ::= (class-name NAME? INITARG*)
NAME ::= :name symbol
INITARG ::= keyword value

The optional name if given will be automatically assigned to the pipe segment, so that it can be retrieved through FIND-PLACE

See PIPING:FIND-PLACE

Package

verbose.

Source

convenience.lisp.

Macro: with-controller-lock ((&optional controller) &body forms)

Evaluates FORMS with the controller’s lock held.

This will block until it can acquire the lock.

See QUEUE-LOCK

Package

verbose.

Source

controller.lisp.

Macro: with-muffled-logging ((&optional category &rest more-categories) &body body)

Adds the requested categories to the list of muffled categories.

See *MUFFLED-CATEGORIES*

Package

verbose.

Source

muffling.lisp.


5.1.3 Compiler macros

Compiler Macro: debug (categories datum &rest args)
Package

verbose.

Source

message.lisp.

Compiler Macro: error (categories datum &rest args)
Package

verbose.

Source

message.lisp.

Compiler Macro: fatal (categories datum &rest args)
Package

verbose.

Source

message.lisp.

Compiler Macro: info (categories datum &rest args)
Package

verbose.

Source

message.lisp.

Compiler Macro: severe (categories datum &rest args)
Package

verbose.

Source

message.lisp.

Compiler Macro: trace (categories datum &rest args)
Package

verbose.

Source

message.lisp.

Compiler Macro: warn (categories datum &rest args)
Package

verbose.

Source

message.lisp.


5.1.4 Ordinary functions

Function: add-level (priority level)

Adds or updates a level with the given priority and level.

If a level with the requested name already exists, its priority is updated. Otherwise a new level is added.

See *LEVELS*

Package

verbose.

Source

message.lisp.

Function: add-pipe (&rest segments)

Adds a new pipe to the controller.

The first argument may be the controller object to modify.

Constructs a pipe with the given segments as per MAKE-PIPE and INSERT, then finally adds the segment to the controller by ADD-SEGMENT.

Package

verbose.

Source

convenience.lisp.

Function: add-repl-category (&rest category)

Convenience function to add more categories.

The first argument may be the controller object to modify.

See REPL-CATEGORIES

Package

verbose.

Source

convenience.lisp.

Function: debug (categories datum &rest args)

Log to the DEBUG level.

Package

verbose.

Source

message.lisp.

Function: error (categories datum &rest args)

Log to the ERROR level.

Package

verbose.

Source

message.lisp.

Function: fatal (categories datum &rest args)

Log to the FATAL level.

Package

verbose.

Source

message.lisp.

Function: info (categories datum &rest args)

Log to the INFO level.

Package

verbose.

Source

message.lisp.

Function: log-message (level categories content &optional class &rest initargs)

Constructs a logging message and sends it off to be logged.

See *DEFAULT-MESSAGE-CLASS*
See LOG-OBJECT

Package

verbose.

Source

message.lisp.

Function: log-object (object)

Passes the given object to the global controller if it exists.

See *GLOBAL-CONTROLLER*
See PIPING:PASS

Package

verbose.

Source

message.lisp.

Function: make-standard-global-controller (&rest initargs)

Constructs a new controller object with a single pipe in the pipeline

The pipe has a level-filter, category-tree-filter, and repl-faucet.

All arguments to this function are simply passed as initargs to the construction of the CONTROLLER instance.

See LEVEL-FILTER
See CATEGORY-TREE-FILTER
See REPL-FAUCET
See CONTROLLER

Package

verbose.

Source

convenience.lisp.

Function: matching-tree-category (filter category)

This returns T if

FILTER and CATEGORY are EQL or
Both can be turned into sequences of items by splitting their SYMBOL-NAMEs on every occurrence of a period and each item in the list made from FILTER occurs in the same order at the beginning of the list made from CATEGORY.

More simply put, if category is a sub-branch of filter, it passes the test.

Package

verbose.

Source

pipes.lisp.

Function: output-here (&optional standard-output controller)

Modifies the standard repl faucet to output to the given stream.

Also useful when the *STANDARD-OUTPUT* changes, such as in the case of SWANK and multiple connections to the same instance.

See REPL-FAUCET

Package

verbose.

Source

convenience.lisp.

Function: remove-global-controller ()

Stops and entirely removes the global controller, if present.

See STOP
See *GLOBAL-CONTROLLER*

Package

verbose.

Source

convenience.lisp.

Function: remove-repl-category (&rest category)

Convenience function to remove repl categories.

The first argument may be the controller object to modify.

See REPL-CATEGORIES

Package

verbose.

Source

convenience.lisp.

Function: repl-categories (&optional controller)

Accessor to the categories that will be printed at the REPL.

See CATEGORY-TREE-FILTER
See ADD-REPL-CATEGORY
See REMOVE-REPL-CATEGORY

Package

verbose.

Source

convenience.lisp.

Function: (setf repl-categories) (&optional controller)
Package

verbose.

Source

convenience.lisp.

Function: repl-level (&optional controller)

Accessor to the current logging level that should be output to the REPL.

See LEVEL-FILTER
See *LEVELS*

Package

verbose.

Source

convenience.lisp.

Function: (setf repl-level) (&optional controller)
Package

verbose.

Source

convenience.lisp.

Function: restart-global-controller ()

Replaces the current global controller (if any) with a freshly allocated one.

In case things really messed up somehow, this may resolve your problems at the cost of throwing away messages that are still queued up, and restoring the standard pipeline.

See REMOVE-GLOBAL-CONTROLLER
See *GLOBAL-CONTROLLER*
See MAKE-STANDARD-GLOBAL-CONTROLLER

Package

verbose.

Source

convenience.lisp.

Function: severe (categories datum &rest args)

Log to the SEVERE level.

Package

verbose.

Source

message.lisp.

Function: sync (&optional controller)

Blocks the current thread until all messages before this point have been processed.

If the controller is not running a thread, this does nothing.
Otherwise this is achieved by constructing and then passing
a SYNC-REQUEST instance to the controller.

See SYNC-REQUEST

Package

verbose.

Source

sync-request.lisp.

Reader: sync-request-condition (instance)

Accessor to the condition variable for the sync request.

See SYNC-REQUEST

Package

verbose.

Source

sync-request.lisp.

Target Slot

condition.

Writer: (setf sync-request-condition) (instance)
Package

verbose.

Source

sync-request.lisp.

Target Slot

condition.

Reader: sync-request-lock (instance)

Accessor to the lock for the sync request.

See SYNC-REQUEST

Package

verbose.

Source

sync-request.lisp.

Target Slot

lock.

Writer: (setf sync-request-lock) (instance)
Package

verbose.

Source

sync-request.lisp.

Target Slot

lock.

Function: trace (categories datum &rest args)

Log to the TRACE level.

Package

verbose.

Source

message.lisp.

Function: warn (categories datum &rest args)

Log to the WARN level.

Package

verbose.

Source

message.lisp.


5.1.5 Generic functions

Generic Reader: categories (object)

The categories against which the object operates.

See MESSAGE
See CATEGORY-FILTER

Package

verbose.

Methods
Reader Method: categories ((category-filter category-filter))

automatically generated reader method

Source

pipes.lisp.

Target Slot

categories.

Reader Method: categories ((message message))

automatically generated reader method

Source

message.lisp.

Target Slot

categories.

Generic Writer: (setf categories) (object)
Package

verbose.

Methods
Writer Method: (setf categories) ((category-filter category-filter))

automatically generated writer method

Source

pipes.lisp.

Target Slot

categories.

Writer Method: (setf categories) ((message message))

automatically generated writer method

Source

message.lisp.

Target Slot

categories.

Generic Reader: content (object)

The primary content that the message carries.

Usually when the message is formatted, this will be printed by PRINC.

See FORMAT-MESSAGE
See MESSAGE

Package

verbose.

Methods
Reader Method: content ((message message))

automatically generated reader method

Source

message.lisp.

Target Slot

content.

Generic Writer: (setf content) (object)
Package

verbose.

Methods
Writer Method: (setf content) ((message message))

automatically generated writer method

Source

message.lisp.

Target Slot

content.

Generic Function: controller-loop (controller)

Main function of the controller’s background thread. Should handle message processing.

This function should return when THREAD-CONTINUE is set to NIL.

See CONTROLLER

Package

verbose.

Methods
Method: controller-loop ((controller controller))
Source

controller.lisp.

Generic Reader: file (object)

Accessor to the file to which the faucet is currently outputting.

Package

verbose.

Methods
Reader Method: file ((file-faucet file-faucet))

automatically generated reader method

Source

pipes.lisp.

Target Slot

file.

Generic Writer: (setf file) (object)
Package

verbose.

Methods
Writer Method: (setf file) ((faucet file-faucet))
Source

pipes.lisp.

Target Slot

file.

Generic Function: format-message (stream message)

Formats the message according to the given thing.

Standard implementations exist for NULL and STREAM.
NULL will always return a string, and STREAM will print the message to the stream.

You will want to extend or override methods on this to change the way messages are presented.

See MESSAGE

Package

verbose.

Methods
Method: format-message ((faucet stream-faucet) (message message))
Source

pipes.lisp.

Method: format-message :after ((faucet stream-faucet) thing)
Source

pipes.lisp.

Method: format-message :before ((faucet stream-faucet) thing)
Source

pipes.lisp.

Method: format-message ((null null) (message message))
Source

message.lisp.

Method: format-message ((null null) (func function))
Source

message.lisp.

Method: format-message ((null null) message)
Source

message.lisp.

Method: format-message ((stream stream) (message message))
Source

message.lisp.

Generic Reader: interval (object)

The interval in which the faucet’s file is rotated.

Can be one of :HOURLY :DAILY :MONTHLY :WEEKLY

See ROTATING-LOG-FAUCET

Package

verbose.

Methods
Reader Method: interval ((rotating-file-faucet rotating-file-faucet))

automatically generated reader method

Source

pipes.lisp.

Target Slot

interval.

Generic Writer: (setf interval) (object)
Package

verbose.

Methods
Writer Method: (setf interval) ((faucet rotating-file-faucet))
Source

pipes.lisp.

Target Slot

interval.

Generic Reader: last-rotation (object)

The universal-time timestamp of the last rotation.

See ROTATE
See ROTATING-LOG-FAUCET

Package

verbose.

Methods
Reader Method: last-rotation ((rotating-file-faucet rotating-file-faucet))

automatically generated reader method

Source

pipes.lisp.

Target Slot

last-rotation.

Generic Writer: (setf last-rotation) (object)
Package

verbose.

Methods
Writer Method: (setf last-rotation) ((rotating-file-faucet rotating-file-faucet))

automatically generated writer method

Source

pipes.lisp.

Target Slot

last-rotation.

Generic Reader: level (object)

The level at which the object operates.

See *LEVELS*
See MESSAGE
See LEVEL-FILTER

Package

verbose.

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

automatically generated reader method

Source

pipes.lisp.

Target Slot

level.

Reader Method: level ((message message))

automatically generated reader method

Source

message.lisp.

Target Slot

level.

Generic Function: (setf level) (object)
Package

verbose.

Methods
Writer Method: (setf level) :before ((filter level-filter))
Source

pipes.lisp.

Target Slot

level.

Method: (setf level) ((level-filter level-filter))

automatically generated writer method

Source

pipes.lisp.

Writer Method: (setf level) ((message message))

automatically generated writer method

Source

message.lisp.

Target Slot

level.

Generic Function: log (level categories datum &rest args)

Causes a message to be logged as appropriate for the given datum.

By default, methods for STRING, SYMBOL, FUNCTION, and T exist. STRING — The string is taken as a format string and the args as format arguments.
SYMBOL — The symbol is taken as condition or class name and a condition/class is constructed with the args as initargs.
FUNCTION — The function is wrapped in a lambda as a call with the arguments. This will then cause the function to get called during the processing of the message when FORMAT-MESSAGE is called.
T — The arguments are discarded and the datum is used as the CONTENT of the message.

See LOG-MESSAGE

Package

verbose.

Methods
Method: log (level categories (datum condition) &rest args)
Source

conditions.lisp.

Method: log (level categories datum &rest args)
Source

message.lisp.

Method: log (level categories (datum function) &rest args)
Source

message.lisp.

Method: log (level categories (datum symbol) &rest args)
Source

message.lisp.

Method: log (level categories (datum string) &rest args)
Source

message.lisp.

Generic Reader: message-condition (object)

Accessor to the condition that the message carries.

See CONDITION-MESSAGE

Package

verbose.

Methods
Reader Method: message-condition ((condition-message condition-message))

automatically generated reader method

Source

conditions.lisp.

Target Slot

condition.

Generic Writer: (setf message-condition) (object)
Package

verbose.

Methods
Writer Method: (setf message-condition) ((condition-message condition-message))

automatically generated writer method

Source

conditions.lisp.

Target Slot

condition.

Generic Reader: output (object)

The stream to which the stream-faucet outputs the messages.

See STREAM-FAUCET

Package

verbose.

Methods
Reader Method: output ((stream-faucet stream-faucet))

automatically generated reader method

Source

pipes.lisp.

Target Slot

output.

Generic Writer: (setf output) (object)
Package

verbose.

Methods
Writer Method: (setf output) ((stream-faucet stream-faucet))

automatically generated writer method

Source

pipes.lisp.

Target Slot

output.

Generic Reader: queue (object)

The vector for the front message queue.

In order to add messages to this queue, you should use VECTOR-PUSH-EXTEND wrapped in a WITH-CONTROLLER-LOCK.

See CONTROLLER

Package

verbose.

Methods
Reader Method: queue ((controller controller))

automatically generated reader method

Source

controller.lisp.

Target Slot

queue.

Generic Writer: (setf queue) (object)
Package

verbose.

Methods
Writer Method: (setf queue) ((controller controller))

automatically generated writer method

Source

controller.lisp.

Target Slot

queue.

Generic Reader: queue-back (object)

The back queue for the controller.

This is swapped with the front QUEUE when the controller decides to start processing messages.

See CONTROLLER

Package

verbose.

Methods
Reader Method: queue-back ((controller controller))

automatically generated reader method

Source

controller.lisp.

Target Slot

queue-back.

Generic Writer: (setf queue-back) (object)
Package

verbose.

Methods
Writer Method: (setf queue-back) ((controller controller))

automatically generated writer method

Source

controller.lisp.

Target Slot

queue-back.

Generic Reader: queue-condition (object)

The condition variable the controller will wait on until signalled.

See CONTROLLER

Package

verbose.

Methods
Reader Method: queue-condition ((controller controller))

automatically generated reader method

Source

controller.lisp.

Target Slot

queue-condition.

Generic Reader: queue-lock (object)

The lock to mutually exclude the controller thread and other threads from accessing the queues simultaneously.

See CONTROLLER

Package

verbose.

Methods
Reader Method: queue-lock ((controller controller))

automatically generated reader method

Source

controller.lisp.

Target Slot

queue-lock.

Generic Function: rotate (faucet &optional new-file)

Causes the faucet to rotate to a new file immediately.

See ROTATING-LOG-FAUCET

Package

verbose.

Methods
Method: rotate ((faucet rotating-file-faucet) &optional new-file)
Source

pipes.lisp.

Generic Function: start (controller)

Starts the background thread of the controller.

If there is no thread support, this does nothing.
If there is already a thread active on the controller, a continuable error is signalled.

See CONTROLLER

Package

verbose.

Methods
Method: start ((controller controller))
Source

controller.lisp.

Generic Function: stop (controller)

Stops the background thread of the controller.

If there is no thread support, this does nothing.
This function may take up to ~0.5s as it waits for the thread to exit on its own. If it still fails then, it will call BT:DESTROY-THREAD and hope that it will terminate properly.

See CONTROLLER

Package

verbose.

Methods
Method: stop ((controller controller))
Source

controller.lisp.

Generic Reader: template (object)

The pathname serving as a template for the rotated files.

See ROTATING-LOG-FAUCET

Package

verbose.

Methods
Reader Method: template ((rotating-file-faucet rotating-file-faucet))

automatically generated reader method

Source

pipes.lisp.

Target Slot

template.

Generic Writer: (setf template) (object)
Package

verbose.

Methods
Writer Method: (setf template) ((rotating-file-faucet rotating-file-faucet))

automatically generated writer method

Source

pipes.lisp.

Target Slot

template.

Generic Reader: thread (object)

Accessor to the thread held by the object.

See CONTROLLER
See MESSAGE

Package

verbose.

Methods
Reader Method: thread ((message message))

automatically generated reader method

Source

message.lisp.

Target Slot

thread.

Reader Method: thread ((controller controller))

automatically generated reader method

Source

controller.lisp.

Target Slot

thread.

Generic Writer: (setf thread) (object)
Package

verbose.

Methods
Writer Method: (setf thread) ((message message))

automatically generated writer method

Source

message.lisp.

Target Slot

thread.

Writer Method: (setf thread) ((controller controller))

automatically generated writer method

Source

controller.lisp.

Target Slot

thread.

Generic Reader: thread-continue (object)

Whether the controller thread should continue or not.

See CONTROLLER

Package

verbose.

Methods
Reader Method: thread-continue ((controller controller))

automatically generated reader method

Source

controller.lisp.

Target Slot

thread-continue.

Generic Writer: (setf thread-continue) (object)
Package

verbose.

Methods
Writer Method: (setf thread-continue) ((controller controller))

automatically generated writer method

Source

controller.lisp.

Target Slot

thread-continue.

Generic Reader: timestamp (object)

The timestamp recorded from the time of issuing of the message.

See LOCAL-TIME:TIMESTAMP
See MESSAGE

Package

verbose.

Methods
Reader Method: timestamp ((message message))

automatically generated reader method

Source

message.lisp.

Target Slot

timestamp.

Generic Writer: (setf timestamp) (object)
Package

verbose.

Methods
Writer Method: (setf timestamp) ((message message))

automatically generated writer method

Source

message.lisp.

Target Slot

timestamp.


5.1.6 Standalone methods

Method: initialize-instance :before ((message message) &key level categories)
Source

message.lisp.

Method: initialize-instance :after ((controller controller) &key dont-start)
Source

controller.lisp.

Method: initialize-instance :after ((faucet file-faucet) &key file)
Source

pipes.lisp.

Method: initialize-instance :after ((filter level-filter) &key level)
Source

pipes.lisp.

Method: initialize-instance :after ((faucet rotating-file-faucet) &key interval)
Source

pipes.lisp.

Method: pass ((faucet stream-faucet) message)
Package

piping.

Source

pipes.lisp.

Method: pass ((filter category-filter) (message message))
Package

piping.

Source

pipes.lisp.

Method: pass ((controller controller) (message message))
Package

piping.

Source

muffling.lisp.

Method: pass ((filter category-tree-filter) (message message))
Package

piping.

Source

pipes.lisp.

Method: pass ((filter level-filter) (message message))
Package

piping.

Source

pipes.lisp.

Method: pass ((controller controller) message)
Package

piping.

Source

controller.lisp.

Method: pass ((vector vector) (sync sync-request))
Package

piping.

Source

sync-request.lisp.

Method: pass :before ((faucet rotating-file-faucet) thing)
Package

piping.

Source

pipes.lisp.

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

message.lisp.

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

controller.lisp.

Method: print-object ((faucet repl-faucet) stream)
Source

pipes.lisp.


5.1.7 Structures

Structure: sync-request

Struct to hold a request for synchronisation.

When this object is processed by being passed down a vector it will first acquire and immediately release its lock and then notify its condition variable. The lock serves as a rendezvous point.

See SYNC-REQUEST-CONDITION
See SYNC-REQUEST-LOCK
See SYNC

Package

verbose.

Source

sync-request.lisp.

Direct superclasses

structure-object.

Direct methods

pass.

Direct slots
Slot: condition
Package

common-lisp.

Initform

(bordeaux-threads:make-condition-variable)

Readers

sync-request-condition.

Writers

(setf sync-request-condition).

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

sync-request-lock.

Writers

(setf sync-request-lock).


Previous: , Up: Public Interface   [Contents][Index]

5.1.8 Classes

Class: category-filter

Only lets through messages that contain a category in the filter’s categories list.

CATEGORIES can be T in which case all messages are let through.

See CATEGORIES
See PIPING:FILTER

Package

verbose.

Source

pipes.lisp.

Direct superclasses

filter.

Direct subclasses

category-tree-filter.

Direct methods
Direct slots
Slot: categories
Initform

t

Initargs

:categories

Readers

categories.

Writers

(setf categories).

Class: category-tree-filter

Only lets through messages that match a category in the filter’s category list.

See MATCHING-TREE-CATEGORY
See CATEGORY-FILTER

Package

verbose.

Source

pipes.lisp.

Direct superclasses

category-filter.

Direct methods

pass.

Class: condition-message

Message class to handle conditions being logged.

See *VERBOSE-CONDITIONS*
See MESSAGE-CONDITION

Package

verbose.

Source

conditions.lisp.

Direct superclasses

message.

Direct methods
Direct Default Initargs
InitargValue
:condition(error condition required.)
Direct slots
Slot: condition
Package

common-lisp.

Initargs

:condition

Readers

message-condition.

Writers

(setf message-condition).

Class: controller

This is the central piece that handles log messages.

By default a background thread is spawned that processes the messages. You can control the thread with START and STOP and enqueue messages with PASS. You can prevent the controller from being automatically STARTed by passing :DONT-START T as an initarg.

See THREAD
See THREAD-CONTINUE
See QUEUE
See QUEUE-BACK
See QUEUE-CONDITION
See QUEUE-LOCK
See START
See STOP
See PIPING:PASS

Package

verbose.

Source

controller.lisp.

Direct superclasses

pipeline.

Direct methods
Direct slots
Slot: thread
Readers

thread.

Writers

(setf thread).

Slot: thread-continue
Readers

thread-continue.

Writers

(setf thread-continue).

Slot: queue
Initform

(make-array (quote (10)) :adjustable t :fill-pointer 0)

Readers

queue.

Writers

(setf queue).

Slot: queue-back
Initform

(make-array (quote (10)) :adjustable t :fill-pointer 0)

Readers

queue-back.

Writers

(setf queue-back).

Slot: queue-condition
Initform

(bordeaux-threads:make-condition-variable :name "message-condition")

Readers

queue-condition.

Writers

This slot is read-only.

Slot: queue-lock
Initform

(bordeaux-threads:make-lock "message-lock")

Readers

queue-lock.

Writers

This slot is read-only.

Class: file-faucet

A faucet that outputs to a file.

See FILE
See STREAM-FAUCET

Package

verbose.

Source

pipes.lisp.

Direct superclasses

stream-faucet.

Direct subclasses

rotating-file-faucet.

Direct methods
Direct Default Initargs
InitargValue
:fileverbose.log
Direct slots
Slot: file
Readers

file.

Writers

(setf file).

Class: level-filter

Only lets through messages that are of the given level or higher.

LEVEL can be either the name of a level in *LEVELS* or an integer of the appropriate size.

See LEVEL
See PIPING:FILTER

Package

verbose.

Source

pipes.lisp.

Direct superclasses

filter.

Direct methods
Direct Default Initargs
InitargValue
:levelinfo
Direct slots
Slot: level
Initform

:info

Readers

level.

Writers

(setf level).

Class: message

The base class for most logging messages that will be sent through the framework.

See TIMESTAMP
See THREAD
See LEVEL
See CATEGORIES
See CONTENT
See FORMAT-MESSAGE
See LOG-MESSAGE

Package

verbose.

Source

message.lisp.

Direct subclasses

condition-message.

Direct methods
Direct Default Initargs
InitargValue
:timestamp(now)
:thread(current-thread)
:levelinfo
:categoriesnil
:contentnil
Direct slots
Slot: timestamp
Initargs

:timestamp

Readers

timestamp.

Writers

(setf timestamp).

Slot: thread
Initargs

:thread

Readers

thread.

Writers

(setf thread).

Slot: level
Initargs

:level

Readers

level.

Writers

(setf level).

Slot: categories
Initargs

:categories

Readers

categories.

Writers

(setf categories).

Slot: content
Initargs

:content

Readers

content.

Writers

(setf content).

Class: repl-faucet

A faucet that prints to the *standard-output*.

See REPL-FAUCET

Package

verbose.

Source

pipes.lisp.

Direct superclasses

stream-faucet.

Direct methods

print-object.

Direct slots
Slot: output
Initform

*standard-output*

Class: rotating-file-faucet
Package

verbose.

Source

pipes.lisp.

Direct superclasses

file-faucet.

Direct methods
Direct Default Initargs
InitargValue
:intervaldaily
:filenil
Direct slots
Slot: interval
Readers

interval.

Writers

(setf interval).

Slot: last-rotation
Initform

0

Readers

last-rotation.

Writers

(setf last-rotation).

Slot: template
Initargs

:template

Readers

template.

Writers

(setf template).

Class: stream-faucet

A faucet that prints the messages it receives to a stream.

Messages are first passed through FORMAT-MESSAGE on the faucet itself, and then on the output stream.

See OUTPUT
See PIPING:FAUCET

Package

verbose.

Source

pipes.lisp.

Direct superclasses

faucet.

Direct subclasses
Direct methods
Direct slots
Slot: output
Initargs

:output

Readers

output.

Writers

(setf output).


5.2 Internals


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

5.2.1 Special variables

Special Variable: *verbose-conditions*

Whether to print a full stack trace with a condition.

See DISSECT:PRESENT

Package

verbose.

Source

conditions.lisp.


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

5.2.2 Ordinary functions

Function: copy-sync-request (instance)
Package

verbose.

Source

sync-request.lisp.

Function: make-sync-request (&key condition lock)
Package

verbose.

Source

sync-request.lisp.

Function: removef (plist &rest keys)

Constructs a copy of the plist where the key-value pairs in keys are not included.

Package

verbose.

Source

toolkit.lisp.

Function: split (string on)

Splits the STRING into a list of strings where ON is taken as the character to split by.

Package

verbose.

Source

toolkit.lisp.

Function: sync-request-p (object)
Package

verbose.

Source

sync-request.lisp.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   I   L   M   O   P   Q   R   S   T   W  
Index Entry  Section

(
(setf categories): Public generic functions
(setf categories): Public generic functions
(setf categories): Public generic functions
(setf content): Public generic functions
(setf content): Public generic functions
(setf file): Public generic functions
(setf file): Public generic functions
(setf interval): Public generic functions
(setf interval): Public generic functions
(setf last-rotation): Public generic functions
(setf last-rotation): Public generic functions
(setf level): Public generic functions
(setf level): Public generic functions
(setf level): Public generic functions
(setf level): Public generic functions
(setf message-condition): Public generic functions
(setf message-condition): Public generic functions
(setf output): Public generic functions
(setf output): Public generic functions
(setf queue): Public generic functions
(setf queue): Public generic functions
(setf queue-back): Public generic functions
(setf queue-back): Public generic functions
(setf repl-categories): Public ordinary functions
(setf repl-level): Public ordinary functions
(setf sync-request-condition): Public ordinary functions
(setf sync-request-lock): Public ordinary functions
(setf template): Public generic functions
(setf template): Public generic functions
(setf thread): Public generic functions
(setf thread): Public generic functions
(setf thread): Public generic functions
(setf thread-continue): Public generic functions
(setf thread-continue): Public generic functions
(setf timestamp): Public generic functions
(setf timestamp): Public generic functions

A
add-level: Public ordinary functions
add-pipe: Public ordinary functions
add-repl-category: Public ordinary functions

C
categories: Public generic functions
categories: Public generic functions
categories: Public generic functions
Compiler Macro, debug: Public compiler macros
Compiler Macro, error: Public compiler macros
Compiler Macro, fatal: Public compiler macros
Compiler Macro, info: Public compiler macros
Compiler Macro, severe: Public compiler macros
Compiler Macro, trace: Public compiler macros
Compiler Macro, warn: Public compiler macros
content: Public generic functions
content: Public generic functions
controller-loop: Public generic functions
controller-loop: Public generic functions
copy-sync-request: Private ordinary functions

D
debug: Public compiler macros
debug: Public ordinary functions
define-level: Public macros
define-pipe: Public macros

E
error: Public compiler macros
error: Public ordinary functions

F
fatal: Public compiler macros
fatal: Public ordinary functions
file: Public generic functions
file: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
format-message: Public generic functions
Function, (setf repl-categories): Public ordinary functions
Function, (setf repl-level): Public ordinary functions
Function, (setf sync-request-condition): Public ordinary functions
Function, (setf sync-request-lock): Public ordinary functions
Function, add-level: Public ordinary functions
Function, add-pipe: Public ordinary functions
Function, add-repl-category: Public ordinary functions
Function, copy-sync-request: Private ordinary functions
Function, debug: Public ordinary functions
Function, error: Public ordinary functions
Function, fatal: Public ordinary functions
Function, info: Public ordinary functions
Function, log-message: Public ordinary functions
Function, log-object: Public ordinary functions
Function, make-standard-global-controller: Public ordinary functions
Function, make-sync-request: Private ordinary functions
Function, matching-tree-category: Public ordinary functions
Function, output-here: Public ordinary functions
Function, remove-global-controller: Public ordinary functions
Function, remove-repl-category: Public ordinary functions
Function, removef: Private ordinary functions
Function, repl-categories: Public ordinary functions
Function, repl-level: Public ordinary functions
Function, restart-global-controller: Public ordinary functions
Function, severe: Public ordinary functions
Function, split: Private ordinary functions
Function, sync: Public ordinary functions
Function, sync-request-condition: Public ordinary functions
Function, sync-request-lock: Public ordinary functions
Function, sync-request-p: Private ordinary functions
Function, trace: Public ordinary functions
Function, warn: Public ordinary functions

G
Generic Function, (setf categories): Public generic functions
Generic Function, (setf content): Public generic functions
Generic Function, (setf file): Public generic functions
Generic Function, (setf interval): Public generic functions
Generic Function, (setf last-rotation): Public generic functions
Generic Function, (setf level): Public generic functions
Generic Function, (setf message-condition): Public generic functions
Generic Function, (setf output): Public generic functions
Generic Function, (setf queue): Public generic functions
Generic Function, (setf queue-back): Public generic functions
Generic Function, (setf template): Public generic functions
Generic Function, (setf thread): Public generic functions
Generic Function, (setf thread-continue): Public generic functions
Generic Function, (setf timestamp): Public generic functions
Generic Function, categories: Public generic functions
Generic Function, content: Public generic functions
Generic Function, controller-loop: Public generic functions
Generic Function, file: Public generic functions
Generic Function, format-message: Public generic functions
Generic Function, interval: Public generic functions
Generic Function, last-rotation: Public generic functions
Generic Function, level: Public generic functions
Generic Function, log: Public generic functions
Generic Function, message-condition: Public generic functions
Generic Function, output: Public generic functions
Generic Function, queue: Public generic functions
Generic Function, queue-back: Public generic functions
Generic Function, queue-condition: Public generic functions
Generic Function, queue-lock: Public generic functions
Generic Function, rotate: Public generic functions
Generic Function, start: Public generic functions
Generic Function, stop: Public generic functions
Generic Function, template: Public generic functions
Generic Function, thread: Public generic functions
Generic Function, thread-continue: Public generic functions
Generic Function, timestamp: Public generic functions

I
info: Public compiler macros
info: Public ordinary functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
interval: Public generic functions
interval: Public generic functions

L
last-rotation: Public generic functions
last-rotation: Public generic functions
level: Public generic functions
level: Public generic functions
level: Public generic functions
log: Public generic functions
log: Public generic functions
log: Public generic functions
log: Public generic functions
log: Public generic functions
log: Public generic functions
log-message: Public ordinary functions
log-object: Public ordinary functions

M
Macro, define-level: Public macros
Macro, define-pipe: Public macros
Macro, with-controller-lock: Public macros
Macro, with-muffled-logging: Public macros
make-standard-global-controller: Public ordinary functions
make-sync-request: Private ordinary functions
matching-tree-category: Public ordinary functions
message-condition: Public generic functions
message-condition: Public generic functions
Method, (setf categories): Public generic functions
Method, (setf categories): Public generic functions
Method, (setf content): Public generic functions
Method, (setf file): Public generic functions
Method, (setf interval): Public generic functions
Method, (setf last-rotation): Public generic functions
Method, (setf level): Public generic functions
Method, (setf level): Public generic functions
Method, (setf level): Public generic functions
Method, (setf message-condition): Public generic functions
Method, (setf output): Public generic functions
Method, (setf queue): Public generic functions
Method, (setf queue-back): Public generic functions
Method, (setf template): Public generic functions
Method, (setf thread): Public generic functions
Method, (setf thread): Public generic functions
Method, (setf thread-continue): Public generic functions
Method, (setf timestamp): Public generic functions
Method, categories: Public generic functions
Method, categories: Public generic functions
Method, content: Public generic functions
Method, controller-loop: Public generic functions
Method, file: Public generic functions
Method, format-message: Public generic functions
Method, format-message: Public generic functions
Method, format-message: Public generic functions
Method, format-message: Public generic functions
Method, format-message: Public generic functions
Method, format-message: Public generic functions
Method, format-message: Public generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, interval: Public generic functions
Method, last-rotation: Public generic functions
Method, level: Public generic functions
Method, level: Public generic functions
Method, log: Public generic functions
Method, log: Public generic functions
Method, log: Public generic functions
Method, log: Public generic functions
Method, log: Public generic functions
Method, message-condition: Public generic functions
Method, output: Public generic functions
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, pass: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, queue: Public generic functions
Method, queue-back: Public generic functions
Method, queue-condition: Public generic functions
Method, queue-lock: Public generic functions
Method, rotate: Public generic functions
Method, start: Public generic functions
Method, stop: Public generic functions
Method, template: Public generic functions
Method, thread: Public generic functions
Method, thread: Public generic functions
Method, thread-continue: Public generic functions
Method, timestamp: Public generic functions

O
output: Public generic functions
output: Public generic functions
output-here: Public ordinary functions

P
pass: Public standalone methods
pass: Public standalone methods
pass: Public standalone methods
pass: Public standalone methods
pass: Public standalone methods
pass: Public standalone methods
pass: Public standalone methods
pass: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

Q
queue: Public generic functions
queue: Public generic functions
queue-back: Public generic functions
queue-back: Public generic functions
queue-condition: Public generic functions
queue-condition: Public generic functions
queue-lock: Public generic functions
queue-lock: Public generic functions

R
remove-global-controller: Public ordinary functions
remove-repl-category: Public ordinary functions
removef: Private ordinary functions
repl-categories: Public ordinary functions
repl-level: Public ordinary functions
restart-global-controller: Public ordinary functions
rotate: Public generic functions
rotate: Public generic functions

S
severe: Public compiler macros
severe: Public ordinary functions
split: Private ordinary functions
start: Public generic functions
start: Public generic functions
stop: Public generic functions
stop: Public generic functions
sync: Public ordinary functions
sync-request-condition: Public ordinary functions
sync-request-lock: Public ordinary functions
sync-request-p: Private ordinary functions

T
template: Public generic functions
template: Public generic functions
thread: Public generic functions
thread: Public generic functions
thread: Public generic functions
thread-continue: Public generic functions
thread-continue: Public generic functions
timestamp: Public generic functions
timestamp: Public generic functions
trace: Public compiler macros
trace: Public ordinary functions

W
warn: Public compiler macros
warn: Public ordinary functions
with-controller-lock: Public macros
with-muffled-logging: Public macros

Jump to:   (  
A   C   D   E   F   G   I   L   M   O   P   Q   R   S   T   W  

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

A.3 Variables

Jump to:   *  
C   F   I   L   O   Q   S   T  
Index Entry  Section

*
*default-message-class*: Public special variables
*global-controller*: Public special variables
*levels*: Public special variables
*muffled-categories*: Public special variables
*process-locally*: Public special variables
*timestamp-format*: Public special variables
*verbose-conditions*: Private special variables

C
categories: Public classes
categories: Public classes
condition: Public structures
condition: Public classes
content: Public classes

F
file: Public classes

I
interval: Public classes

L
last-rotation: Public classes
level: Public classes
level: Public classes
lock: Public structures

O
output: Public classes
output: Public classes

Q
queue: Public classes
queue-back: Public classes
queue-condition: Public classes
queue-lock: Public classes

S
Slot, categories: Public classes
Slot, categories: Public classes
Slot, condition: Public structures
Slot, condition: Public classes
Slot, content: Public classes
Slot, file: Public classes
Slot, interval: Public classes
Slot, last-rotation: Public classes
Slot, level: Public classes
Slot, level: Public classes
Slot, lock: Public structures
Slot, output: Public classes
Slot, output: Public classes
Slot, queue: Public classes
Slot, queue-back: Public classes
Slot, queue-condition: Public classes
Slot, queue-lock: Public classes
Slot, template: Public classes
Slot, thread: Public classes
Slot, thread: Public classes
Slot, thread-continue: Public classes
Slot, timestamp: Public classes
Special Variable, *default-message-class*: Public special variables
Special Variable, *global-controller*: Public special variables
Special Variable, *levels*: Public special variables
Special Variable, *muffled-categories*: Public special variables
Special Variable, *process-locally*: Public special variables
Special Variable, *timestamp-format*: Public special variables
Special Variable, *verbose-conditions*: Private special variables

T
template: Public classes
thread: Public classes
thread: Public classes
thread-continue: Public classes
timestamp: Public classes

Jump to:   *  
C   F   I   L   O   Q   S   T  

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

A.4 Data types

Jump to:   C   D   F   L   M   P   R   S   T   V  
Index Entry  Section

C
category-filter: Public classes
category-tree-filter: Public classes
Class, category-filter: Public classes
Class, category-tree-filter: Public classes
Class, condition-message: Public classes
Class, controller: Public classes
Class, file-faucet: Public classes
Class, level-filter: Public classes
Class, message: Public classes
Class, repl-faucet: Public classes
Class, rotating-file-faucet: Public classes
Class, stream-faucet: Public classes
condition-message: Public classes
conditions.lisp: The verbose/conditions․lisp file
controller: Public classes
controller.lisp: The verbose/controller․lisp file
convenience.lisp: The verbose/convenience․lisp file

D
documentation.lisp: The verbose/documentation․lisp file

F
File, conditions.lisp: The verbose/conditions․lisp file
File, controller.lisp: The verbose/controller․lisp file
File, convenience.lisp: The verbose/convenience․lisp file
File, documentation.lisp: The verbose/documentation․lisp file
File, message.lisp: The verbose/message․lisp file
File, muffling.lisp: The verbose/muffling․lisp file
File, package.lisp: The verbose/package․lisp file
File, pipes.lisp: The verbose/pipes․lisp file
File, sync-request.lisp: The verbose/sync-request․lisp file
File, toolkit.lisp: The verbose/toolkit․lisp file
File, verbose.asd: The verbose/verbose․asd file
file-faucet: Public classes

L
level-filter: Public classes

M
message: Public classes
message.lisp: The verbose/message․lisp file
muffling.lisp: The verbose/muffling․lisp file

P
Package, verbose: The verbose package
package.lisp: The verbose/package․lisp file
pipes.lisp: The verbose/pipes․lisp file

R
repl-faucet: Public classes
rotating-file-faucet: Public classes

S
stream-faucet: Public classes
Structure, sync-request: Public structures
sync-request: Public structures
sync-request.lisp: The verbose/sync-request․lisp file
System, verbose: The verbose system

T
toolkit.lisp: The verbose/toolkit․lisp file

V
verbose: The verbose system
verbose: The verbose package
verbose.asd: The verbose/verbose․asd file

Jump to:   C   D   F   L   M   P   R   S   T   V