The verbose Reference Manual

Table of Contents

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 2.3 "Robert April" on Tue Feb 20 09:29:52 2018 GMT+0.


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

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-controller before dumping and start-controller after resuming the image. Alternatively you can push :verbose-no-init onto *features* before loading Verbose and then run something similar to (setf v:global-controller (v:make-standard-global-controller)) upon startup.

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


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 verbose

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/verbose

License

Artistic

Description

A logging framework using the piping library.

Version

2.0.0

Dependencies
Source

verbose.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 verbose.asd

Location

verbose.asd

Systems

verbose (system)


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

3.1.2 verbose/package.lisp

Parent

verbose (system)

Location

package.lisp

Packages

verbose


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

3.1.3 verbose/toolkit.lisp

Dependency

package.lisp (file)

Parent

verbose (system)

Location

toolkit.lisp

Internal Definitions

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

3.1.4 verbose/controller.lisp

Dependency

toolkit.lisp (file)

Parent

verbose (system)

Location

controller.lisp

Exported Definitions

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

3.1.5 verbose/message.lisp

Dependency

controller.lisp (file)

Parent

verbose (system)

Location

message.lisp

Exported Definitions

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

3.1.6 verbose/pipes.lisp

Dependency

message.lisp (file)

Parent

verbose (system)

Location

pipes.lisp

Exported Definitions

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

3.1.7 verbose/convenience.lisp

Dependency

pipes.lisp (file)

Parent

verbose (system)

Location

convenience.lisp

Exported Definitions

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

3.1.8 verbose/conditions.lisp

Dependency

convenience.lisp (file)

Parent

verbose (system)

Location

conditions.lisp

Exported Definitions
Internal Definitions

*verbose-conditions* (special variable)


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

3.1.9 verbose/muffling.lisp

Dependency

conditions.lisp (file)

Parent

verbose (system)

Location

muffling.lisp

Exported Definitions

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

3.1.10 verbose/sync-request.lisp

Dependency

muffling.lisp (file)

Parent

verbose (system)

Location

sync-request.lisp

Exported Definitions
Internal Definitions

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

3.1.11 verbose/documentation.lisp

Dependency

sync-request.lisp (file)

Parent

verbose (system)

Location

documentation.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 verbose

Source

package.lisp (file)

Nicknames
Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)

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

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

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

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

Special Variable: *timestamp-format*

The format in which timestamps will be formatted for messages.

See LOCAL-TIME:FORMAT-TIMESTRING

Package

verbose

Source

message.lisp (file)


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

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

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

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

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


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

5.1.3 Compiler macros

Compiler Macro: debug CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)

Compiler Macro: error CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)

Compiler Macro: fatal CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)

Compiler Macro: info CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)

Compiler Macro: severe CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)

Compiler Macro: trace CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)

Compiler Macro: warn CATEGORIES DATUM &rest ARGS
Package

verbose

Source

message.lisp (file)


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

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

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

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

Function: debug CATEGORIES DATUM &rest ARGS

Log to the DEBUG level.

Package

verbose

Source

message.lisp (file)

Function: error CATEGORIES DATUM &rest ARGS

Log to the ERROR level.

Package

verbose

Source

message.lisp (file)

Function: fatal CATEGORIES DATUM &rest ARGS

Log to the FATAL level.

Package

verbose

Source

message.lisp (file)

Function: info CATEGORIES DATUM &rest ARGS

Log to the INFO level.

Package

verbose

Source

message.lisp (file)

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

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

Function: make-standard-global-controller ()

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

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

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

Package

verbose

Source

convenience.lisp (file)

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

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

Function: remove-global-controller ()

Stops and entirely removes the global controller, if present.

See STOP
See *GLOBAL-CONTROLLER*

Package

verbose

Source

convenience.lisp (file)

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

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

Writer

(setf repl-categories) (function)

Function: (setf repl-categories) CATEGORIES &optional CONTROLLER
Package

verbose

Source

convenience.lisp (file)

Reader

repl-categories (function)

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

Writer

(setf repl-level) (function)

Function: (setf repl-level) LEVEL &optional CONTROLLER
Package

verbose

Source

convenience.lisp (file)

Reader

repl-level (function)

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.

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

Package

verbose

Source

convenience.lisp (file)

Function: severe CATEGORIES DATUM &rest ARGS

Log to the SEVERE level.

Package

verbose

Source

message.lisp (file)

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

Function: sync-request-condition INSTANCE

Accessor to the condition variable for the sync request.

See SYNC-REQUEST

Package

verbose

Source

sync-request.lisp (file)

Writer

(setf sync-request-condition) (function)

Function: (setf sync-request-condition) VALUE INSTANCE
Package

verbose

Source

sync-request.lisp (file)

Reader

sync-request-condition (function)

Function: sync-request-lock INSTANCE

Accessor to the lock for the sync request.

See SYNC-REQUEST

Package

verbose

Source

sync-request.lisp (file)

Writer

(setf sync-request-lock) (function)

Function: (setf sync-request-lock) VALUE INSTANCE
Package

verbose

Source

sync-request.lisp (file)

Reader

sync-request-lock (function)

Function: trace CATEGORIES DATUM &rest ARGS

Log to the TRACE level.

Package

verbose

Source

message.lisp (file)

Function: warn CATEGORIES DATUM &rest ARGS

Log to the WARN level.

Package

verbose

Source

message.lisp (file)


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

5.1.5 Generic functions

Generic Function: categories OBJECT

The categories against which the object operates.

See MESSAGE
See CATEGORY-FILTER

Package

verbose

Writer

(setf categories) (generic function)

Methods
Method: categories (CATEGORY-FILTER category-filter)

automatically generated reader method

Source

pipes.lisp (file)

Method: categories (MESSAGE message)

automatically generated reader method

Source

message.lisp (file)

Generic Function: (setf categories) NEW-VALUE OBJECT
Package

verbose

Reader

categories (generic function)

Methods
Method: (setf categories) NEW-VALUE (CATEGORY-FILTER category-filter)

automatically generated writer method

Source

pipes.lisp (file)

Method: (setf categories) NEW-VALUE (MESSAGE message)

automatically generated writer method

Source

message.lisp (file)

Generic Function: 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

Writer

(setf content) (generic function)

Methods
Method: content (MESSAGE message)

automatically generated reader method

Source

message.lisp (file)

Generic Function: (setf content) NEW-VALUE OBJECT
Package

verbose

Reader

content (generic function)

Methods
Method: (setf content) NEW-VALUE (MESSAGE message)

automatically generated writer method

Source

message.lisp (file)

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

Generic Function: file OBJECT

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

Package

verbose

Writer

(setf file) (generic function)

Methods
Method: file (FILE-FAUCET file-faucet)

automatically generated reader method

Source

pipes.lisp (file)

Generic Function: (setf file) NEW-VALUE OBJECT
Package

verbose

Reader

file (generic function)

Methods
Method: (setf file) FILE (FAUCET file-faucet)
Source

pipes.lisp (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 (file)

Method: format-message (FAUCET stream-faucet) THING after
Source

pipes.lisp (file)

Method: format-message (FAUCET stream-faucet) THING before
Source

pipes.lisp (file)

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

message.lisp (file)

Method: format-message (NULL null) (FUNC function)
Source

message.lisp (file)

Method: format-message (NULL null) MESSAGE
Source

message.lisp (file)

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

message.lisp (file)

Generic Function: 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

Writer

(setf interval) (generic function)

Methods
Method: interval (ROTATING-FILE-FAUCET rotating-file-faucet)

automatically generated reader method

Source

pipes.lisp (file)

Generic Function: (setf interval) NEW-VALUE OBJECT
Package

verbose

Reader

interval (generic function)

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

pipes.lisp (file)

Generic Function: last-rotation OBJECT

The universal-time timestamp of the last rotation.

See ROTATE
See ROTATING-LOG-FAUCET

Package

verbose

Writer

(setf last-rotation) (generic function)

Methods
Method: last-rotation (ROTATING-FILE-FAUCET rotating-file-faucet)

automatically generated reader method

Source

pipes.lisp (file)

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

verbose

Reader

last-rotation (generic function)

Methods
Method: (setf last-rotation) NEW-VALUE (ROTATING-FILE-FAUCET rotating-file-faucet)

automatically generated writer method

Source

pipes.lisp (file)

Generic Function: level OBJECT

The level at which the object operates.

See *LEVELS*
See MESSAGE
See LEVEL-FILTER

Package

verbose

Writer

(setf level) (generic function)

Methods
Method: level (LEVEL-FILTER level-filter)

automatically generated reader method

Source

pipes.lisp (file)

Method: level (MESSAGE message)

automatically generated reader method

Source

message.lisp (file)

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

verbose

Reader

level (generic function)

Methods
Method: (setf level) NEW-VALUE (LEVEL-FILTER level-filter)

automatically generated writer method

Source

pipes.lisp (file)

Method: (setf level) NEW-VALUE (MESSAGE message)

automatically generated writer method

Source

message.lisp (file)

Method: (setf level) LEVEL (FILTER level-filter) before
Source

pipes.lisp (file)

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

Method: log LEVEL CATEGORIES DATUM &rest ARGS
Source

message.lisp (file)

Method: log LEVEL CATEGORIES (DATUM function) &rest ARGS
Source

message.lisp (file)

Method: log LEVEL CATEGORIES (DATUM symbol) &rest ARGS
Source

message.lisp (file)

Method: log LEVEL CATEGORIES (DATUM string) &rest ARGS
Source

message.lisp (file)

Generic Function: message-condition OBJECT

Accessor to the condition that the message carries.

See CONDITION-MESSAGE

Package

verbose

Writer

(setf message-condition) (generic function)

Methods
Method: message-condition (CONDITION-MESSAGE condition-message)

automatically generated reader method

Source

conditions.lisp (file)

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

verbose

Reader

message-condition (generic function)

Methods
Method: (setf message-condition) NEW-VALUE (CONDITION-MESSAGE condition-message)

automatically generated writer method

Source

conditions.lisp (file)

Generic Function: output OBJECT

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

See STREAM-FAUCET

Package

verbose

Writer

(setf output) (generic function)

Methods
Method: output (STREAM-FAUCET stream-faucet)

automatically generated reader method

Source

pipes.lisp (file)

Generic Function: (setf output) NEW-VALUE OBJECT
Package

verbose

Reader

output (generic function)

Methods
Method: (setf output) NEW-VALUE (STREAM-FAUCET stream-faucet)

automatically generated writer method

Source

pipes.lisp (file)

Generic Function: 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

Writer

(setf queue) (generic function)

Methods
Method: queue (CONTROLLER controller)

automatically generated reader method

Source

controller.lisp (file)

Generic Function: (setf queue) NEW-VALUE OBJECT
Package

verbose

Reader

queue (generic function)

Methods
Method: (setf queue) NEW-VALUE (CONTROLLER controller)

automatically generated writer method

Source

controller.lisp (file)

Generic Function: 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

Writer

(setf queue-back) (generic function)

Methods
Method: queue-back (CONTROLLER controller)

automatically generated reader method

Source

controller.lisp (file)

Generic Function: (setf queue-back) NEW-VALUE OBJECT
Package

verbose

Reader

queue-back (generic function)

Methods
Method: (setf queue-back) NEW-VALUE (CONTROLLER controller)

automatically generated writer method

Source

controller.lisp (file)

Generic Function: queue-condition OBJECT

The condition variable the controller will wait on until signalled.

See CONTROLLER

Package

verbose

Methods
Method: queue-condition (CONTROLLER controller)

automatically generated reader method

Source

controller.lisp (file)

Generic Function: queue-lock OBJECT

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

See CONTROLLER

Package

verbose

Methods
Method: queue-lock (CONTROLLER controller)

automatically generated reader method

Source

controller.lisp (file)

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

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

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

Generic Function: template OBJECT

The pathname serving as a template for the rotated files.

See ROTATING-LOG-FAUCET

Package

verbose

Writer

(setf template) (generic function)

Methods
Method: template (ROTATING-FILE-FAUCET rotating-file-faucet)

automatically generated reader method

Source

pipes.lisp (file)

Generic Function: (setf template) NEW-VALUE OBJECT
Package

verbose

Reader

template (generic function)

Methods
Method: (setf template) NEW-VALUE (ROTATING-FILE-FAUCET rotating-file-faucet)

automatically generated writer method

Source

pipes.lisp (file)

Generic Function: thread OBJECT

Accessor to the thread held by the object.

See CONTROLLER
See MESSAGE

Package

verbose

Writer

(setf thread) (generic function)

Methods
Method: thread (MESSAGE message)

automatically generated reader method

Source

message.lisp (file)

Method: thread (CONTROLLER controller)

automatically generated reader method

Source

controller.lisp (file)

Generic Function: (setf thread) NEW-VALUE OBJECT
Package

verbose

Reader

thread (generic function)

Methods
Method: (setf thread) NEW-VALUE (MESSAGE message)

automatically generated writer method

Source

message.lisp (file)

Method: (setf thread) NEW-VALUE (CONTROLLER controller)

automatically generated writer method

Source

controller.lisp (file)

Generic Function: thread-continue OBJECT

Whether the controller thread should continue or not.

See CONTROLLER

Package

verbose

Writer

(setf thread-continue) (generic function)

Methods
Method: thread-continue (CONTROLLER controller)

automatically generated reader method

Source

controller.lisp (file)

Generic Function: (setf thread-continue) NEW-VALUE OBJECT
Package

verbose

Reader

thread-continue (generic function)

Methods
Method: (setf thread-continue) NEW-VALUE (CONTROLLER controller)

automatically generated writer method

Source

controller.lisp (file)

Generic Function: timestamp OBJECT

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

See LOCAL-TIME:TIMESTAMP
See MESSAGE

Package

verbose

Writer

(setf timestamp) (generic function)

Methods
Method: timestamp (MESSAGE message)

automatically generated reader method

Source

message.lisp (file)

Generic Function: (setf timestamp) NEW-VALUE OBJECT
Package

verbose

Reader

timestamp (generic function)

Methods
Method: (setf timestamp) NEW-VALUE (MESSAGE message)

automatically generated writer method

Source

message.lisp (file)


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

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

Direct superclasses

structure-object (structure)

Direct methods

pass (method)

Direct slots
Slot: condition
Initform

(bordeaux-threads:make-condition-variable)

Readers

sync-request-condition (function)

Writers

(setf sync-request-condition) (function)

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

sync-request-lock (function)

Writers

(setf sync-request-lock) (function)


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

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

Direct superclasses

filter (class)

Direct subclasses

category-tree-filter (class)

Direct methods
  • pass (method)
  • categories (method)
  • categories (method)
Direct slots
Slot: categories
Initargs

:categories

Initform

t

Readers

categories (generic function)

Writers

(setf categories) (generic function)

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

Direct superclasses

category-filter (class)

Direct methods

pass (method)

Class: condition-message ()

Message class to handle conditions being logged.

See *VERBOSE-CONDITIONS*
See MESSAGE-CONDITION

Package

verbose

Source

conditions.lisp (file)

Direct superclasses

message (class)

Direct methods
Direct slots
Slot: condition
Initargs

:condition

Readers

message-condition (generic function)

Writers

(setf message-condition) (generic function)

Direct Default Initargs
InitargValue
:condition(error "condition required.")
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.

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

Direct superclasses

pipeline (class)

Direct methods
Direct slots
Slot: thread
Readers

thread (generic function)

Writers

(setf thread) (generic function)

Slot: thread-continue
Readers

thread-continue (generic function)

Writers

(setf thread-continue) (generic function)

Slot: queue
Initform

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

Readers

queue (generic function)

Writers

(setf queue) (generic function)

Slot: queue-back
Initform

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

Readers

queue-back (generic function)

Writers

(setf queue-back) (generic function)

Slot: queue-condition
Initform

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

Readers

queue-condition (generic function)

Slot: queue-lock
Initform

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

Readers

queue-lock (generic function)

Class: file-faucet ()

A faucet that outputs to a file.

See FILE
See STREAM-FAUCET

Package

verbose

Source

pipes.lisp (file)

Direct superclasses

stream-faucet (class)

Direct subclasses

rotating-file-faucet (class)

Direct methods
  • file (method)
  • initialize-instance (method)
  • file (method)
Direct slots
Slot: file
Readers

file (generic function)

Writers

(setf file) (generic function)

Direct Default Initargs
InitargValue
:file#p"verbose.log"
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 (file)

Direct superclasses

filter (class)

Direct methods
  • pass (method)
  • (setf level) (method)
  • initialize-instance (method)
  • level (method)
  • level (method)
Direct slots
Slot: level
Initform

:info

Readers

level (generic function)

Writers

(setf level) (generic function)

Direct Default Initargs
InitargValue
:level:info
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 (file)

Direct superclasses

standard-object (class)

Direct subclasses

condition-message (class)

Direct methods
Direct slots
Slot: timestamp
Initargs

:timestamp

Readers

timestamp (generic function)

Writers

(setf timestamp) (generic function)

Slot: thread
Initargs

:thread

Readers

thread (generic function)

Writers

(setf thread) (generic function)

Slot: level
Initargs

:level

Readers

level (generic function)

Writers

(setf level) (generic function)

Slot: categories
Initargs

:categories

Readers

categories (generic function)

Writers

(setf categories) (generic function)

Slot: content
Initargs

:content

Readers

content (generic function)

Writers

(setf content) (generic function)

Direct Default Initargs
InitargValue
:timestamp(local-time:now)
:thread(bordeaux-threads:current-thread)
:level:info
:categoriesnil
:contentnil
Class: repl-faucet ()

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

See REPL-FAUCET

Package

verbose

Source

pipes.lisp (file)

Direct superclasses

stream-faucet (class)

Direct methods

print-object (method)

Direct slots
Slot: output
Initform

*standard-output*

Class: rotating-file-faucet ()
Package

verbose

Source

pipes.lisp (file)

Direct superclasses

file-faucet (class)

Direct methods
  • rotate (method)
  • pass (method)
  • interval (method)
  • initialize-instance (method)
  • template (method)
  • template (method)
  • last-rotation (method)
  • last-rotation (method)
  • interval (method)
Direct slots
Slot: interval
Readers

interval (generic function)

Writers

(setf interval) (generic function)

Slot: last-rotation
Initform

0

Readers

last-rotation (generic function)

Writers

(setf last-rotation) (generic function)

Slot: template
Initargs

:template

Readers

template (generic function)

Writers

(setf template) (generic function)

Direct Default Initargs
InitargValue
:interval:daily
:filenil
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 (file)

Direct superclasses

faucet (class)

Direct subclasses
Direct methods
Direct slots
Slot: output
Initargs

:output

Readers

output (generic function)

Writers

(setf output) (generic function)


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

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [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 (file)


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

5.2.2 Functions

Function: copy-sync-request INSTANCE
Package

verbose

Source

sync-request.lisp (file)

Function: make-sync-request &key (CONDITION CONDITION) (LOCK LOCK)
Package

verbose

Source

sync-request.lisp (file)

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

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

Function: sync-request-p OBJECT
Package

verbose

Source

sync-request.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   V  
Index Entry  Section

F
File, Lisp, verbose.asd: The verbose<dot>asd file
File, Lisp, verbose/conditions.lisp: The verbose/conditions<dot>lisp file
File, Lisp, verbose/controller.lisp: The verbose/controller<dot>lisp file
File, Lisp, verbose/convenience.lisp: The verbose/convenience<dot>lisp file
File, Lisp, verbose/documentation.lisp: The verbose/documentation<dot>lisp file
File, Lisp, verbose/message.lisp: The verbose/message<dot>lisp file
File, Lisp, verbose/muffling.lisp: The verbose/muffling<dot>lisp file
File, Lisp, verbose/package.lisp: The verbose/package<dot>lisp file
File, Lisp, verbose/pipes.lisp: The verbose/pipes<dot>lisp file
File, Lisp, verbose/sync-request.lisp: The verbose/sync-request<dot>lisp file
File, Lisp, verbose/toolkit.lisp: The verbose/toolkit<dot>lisp file

L
Lisp File, verbose.asd: The verbose<dot>asd file
Lisp File, verbose/conditions.lisp: The verbose/conditions<dot>lisp file
Lisp File, verbose/controller.lisp: The verbose/controller<dot>lisp file
Lisp File, verbose/convenience.lisp: The verbose/convenience<dot>lisp file
Lisp File, verbose/documentation.lisp: The verbose/documentation<dot>lisp file
Lisp File, verbose/message.lisp: The verbose/message<dot>lisp file
Lisp File, verbose/muffling.lisp: The verbose/muffling<dot>lisp file
Lisp File, verbose/package.lisp: The verbose/package<dot>lisp file
Lisp File, verbose/pipes.lisp: The verbose/pipes<dot>lisp file
Lisp File, verbose/sync-request.lisp: The verbose/sync-request<dot>lisp file
Lisp File, verbose/toolkit.lisp: The verbose/toolkit<dot>lisp file

V
verbose.asd: The verbose<dot>asd file
verbose/conditions.lisp: The verbose/conditions<dot>lisp file
verbose/controller.lisp: The verbose/controller<dot>lisp file
verbose/convenience.lisp: The verbose/convenience<dot>lisp file
verbose/documentation.lisp: The verbose/documentation<dot>lisp file
verbose/message.lisp: The verbose/message<dot>lisp file
verbose/muffling.lisp: The verbose/muffling<dot>lisp file
verbose/package.lisp: The verbose/package<dot>lisp file
verbose/pipes.lisp: The verbose/pipes<dot>lisp file
verbose/sync-request.lisp: The verbose/sync-request<dot>lisp file
verbose/toolkit.lisp: The verbose/toolkit<dot>lisp file

Jump to:   F   L   V  

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

A.2 Functions

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

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

A
add-level: Exported functions
add-pipe: Exported functions
add-repl-category: Exported functions

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

D
debug: Exported compiler macros
debug: Exported functions
define-level: Exported macros
define-pipe: Exported macros

E
error: Exported compiler macros
error: Exported functions

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

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

I
info: Exported compiler macros
info: Exported functions
interval: Exported generic functions
interval: Exported generic functions

L
last-rotation: Exported generic functions
last-rotation: Exported generic functions
level: Exported generic functions
level: Exported generic functions
level: Exported generic functions
log: Exported generic functions
log: Exported generic functions
log: Exported generic functions
log: Exported generic functions
log: Exported generic functions
log: Exported generic functions
log-message: Exported functions
log-object: Exported functions

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

O
output: Exported generic functions
output: Exported generic functions
output-here: Exported functions

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

R
remove-global-controller: Exported functions
remove-repl-category: Exported functions
removef: Internal functions
repl-categories: Exported functions
repl-level: Exported functions
restart-global-controller: Exported functions
rotate: Exported generic functions
rotate: Exported generic functions

S
severe: Exported compiler macros
severe: Exported functions
split: Internal functions
start: Exported generic functions
start: Exported generic functions
stop: Exported generic functions
stop: Exported generic functions
sync: Exported functions
sync-request-condition: Exported functions
sync-request-lock: Exported functions
sync-request-p: Internal functions

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

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

Jump to:   (  
A   C   D   E   F   G   I   L   M   O   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*: Exported special variables
*global-controller*: Exported special variables
*levels*: Exported special variables
*muffled-categories*: Exported special variables
*process-locally*: Exported special variables
*timestamp-format*: Exported special variables
*verbose-conditions*: Internal special variables

C
categories: Exported classes
categories: Exported classes
condition: Exported structures
condition: Exported classes
content: Exported classes

F
file: Exported classes

I
interval: Exported classes

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

O
output: Exported classes
output: Exported classes

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

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

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

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

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

A.4 Data types

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

C
category-filter: Exported classes
category-tree-filter: Exported classes
Class, category-filter: Exported classes
Class, category-tree-filter: Exported classes
Class, condition-message: Exported classes
Class, controller: Exported classes
Class, file-faucet: Exported classes
Class, level-filter: Exported classes
Class, message: Exported classes
Class, repl-faucet: Exported classes
Class, rotating-file-faucet: Exported classes
Class, stream-faucet: Exported classes
condition-message: Exported classes
controller: Exported classes

F
file-faucet: Exported classes

L
level-filter: Exported classes

M
message: Exported classes

P
Package, verbose: The verbose package

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

S
stream-faucet: Exported classes
Structure, sync-request: Exported structures
sync-request: Exported structures
System, verbose: The verbose system

V
verbose: The verbose system
verbose: The verbose package

Jump to:   C   F   L   M   P   R   S   V