The cl-grip Reference Manual

Table of Contents

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

The cl-grip Reference Manual

This is the cl-grip Reference Manual, version 0.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Nov 04 12:16:40 2020 GMT+0.


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

1 Introduction

=============================================
``cl-grip`` -- Logging System for Common Lisp
=============================================

Overview
--------

``cl-grip`` is a high-level logging system for Common Lisp, focusing on a
clear user interface, support for flexible structured logging, and easy
extensibility for different backends to support direct logging to various
inputs.

Concepts
--------

Levels
~~~~~~

Grip represents levels of messages as a number between 1 and 100, with "named
levels" occurring at intervals of 10. The levels are defined as constants in
the ``grip.level`` package. The named levels are:

- ``trace``
- ``debug``
- ``info``
- ``notice``
- ``warning``
- ``error``
- ``critical``
- ``alert``
- ``emergency``

Loggers posses a "threshold" level and only messages with levels greater than
or equal to the threshold.

Messages
~~~~~~~~

Messages wrap data sent to the logger and contain additional metadata used in
the production of log messages. Grip's core provides a simple "string" log
message that wraps strings, as well as a "structured" message type that wraps
simple alist/plist and hashmaps.

The following generic functions control message creation and behavior:

- ``loggable-p``
- ``export-message``
- ``make-message``
- ``resolve-output``

Loggers
~~~~~~~

Loggers store configuration and state related to the delivery of log
messages, in the case of loggers that write to streams, this may a reference
to the stream itself, or may include a message buffer, or credentials to an
external service. The primary implementation is the ``stream-journal`` which
writes all messages to the provided stream, standard output by default, or
perhaps a file. There is also a ``base-journal`` which is used as a base class,
and unconditionally prints log lines to standard output. The
``merged-journal`` stores a vector of other journals, and has a
``send-mesage`` method that distributes messages to all loggers.

The following generic functions control logger behavior:

- ``send-message`` delivers the message to the configured output, if the
  message is logable.
- ``format-message`` formats the entire log line.
- ``log>`` send a message at a specific log level. There are implementations
  that take ``base-message`` implementations others that use ``make-message``
  to convert to a message type.

By convention send-message should call ``format-message`` (which can in turn
call ``resolve-message``).

There are also a collection of methods on ``(logger message)`` for each log
level that are implemented generically in terms of ``log>``, they are:

- ``trace>``
- ``debug>``
- ``info>``
- ``notice>``
- ``warning>``
- ``error>``
- ``critical>``
- ``alert>``
- ``emergency>``

Formatters
~~~~~~~~~~

Loggers hold a separate formating object which is responsible for configuring
the output format of log lines. These objects hold configuration and are
passed to the following generic functions:

- ``resolve-output`` is responsible for formating the output of the logging
  payload.
- ``format-message`` is responsible for formating the entire log message,
  typically by calling ``resolve-output``, but also has access to the logger
  itself, and may attach some additional metdata (e.g. the log level and
  logger name.)

Use
---

Core Logging Functionality
~~~~~~~~~~~~~~~~~~~~~~~~~~

The core "grip" system has very few external dependencies, and a secondary
"ext" system contains implementations that rely on other external libraries,
which you can opt into as needed.

By default you can load the ``grip`` package and begin using the logging
methods without further configuration: there is a default logger configured so
that the following operations will work: ::

  (grip:info> "log message")

To send structured data: ::

  (grip:info> '(:msg "hello"
	       :value 100))

   (let ((msg (make-hash-table :test #'string=)))
     (setf (gethash "message" msg)  "test message")
     (setf (gethash "value" msg)  val)
     (eel "value" "value")

     (grip:error> msg))

In the more advanced case, you can set up your own logger and populate the
``*default-logger*`` variable in the grip package, as in: ::

  (setf grip:*default-logger* (make-instance 'grip.logger:stream-journal :name "example" :output-target *error-output*))

At this point, you can use the default logging methods which will now send
standard error. Alternately, you can define a logging instance and store it
centerally (or pass it around) and pass it directly to logging methods, as in:
::

  (let ((logger (make-instance 'grip.logger:stream-journal :name "example" :output-target *error-output*)))
    (grip.logger:info> logger "hello world"))

You can easily pass strings, association lists, property lists, hash-tables,
or any type that implements the ``export-message`` method. Additionally, the
``new-message`` function, which is exported from the ``grip`` package, is
useful for creating messages, and provides a few useful additional options:

- To produce with a formatted string content, you can use one of the following
  forms: ::

    (new-message "hello {{name}}, welcome to {{place}}" :args '(("name" . "kip") ("place". "grip")))
    (new-message "hello ~A, welcome to ~A" :args '("kip" "grip"))

  Will produce a message that is formated with substitutions. The first form,
  using alists, uses double-brace substitution (using cl-strings), and the
  second form uses standard ``format`` macro formatting. This type, for
  whatever it's worth defers string processing until the message is logged, at
  which point the resolved message is cached, which may be more efficient for
  longer strings with multiple outputs as well as in cases where messages may
  not be logged.

- To modify the ``conditional`` flag in a message (or ``:when`` argument to
  the message constructor), which will prevent it from being logged. Use this
  to avoid wrapping your logging statements in ``when`` blocks. ::

    (new-message "hello kip!" :when (should-log (now)))

- To define the level when creating the message, which is also available using
  ``make-message``, to facilitate passing messages directly to ``log>``. The
  default level value is ``+debug+`` but this is optional, and safely set to
  the correct level when using a log level method. ::

    (new-message "hello kip!" :level +info+)

Advanced Features
~~~~~~~~~~~~~~~~~

In addition to common workflows, ``cl-grip`` contains a few additional or
non-obvious featres that might be interesting for some use-cases:

JSON Formatting
```````````````

The ``grip.ext.json`` package includes two formatters that produce JSON
formatted output:

- ``json-simple-formatter`` does not annotate messages or add any metadata to
  the output, but sends messages in a JSON format.

- ``json-metadata-formatter`` adds a ``metadata`` field holding a JSON object
  with three fields: time, level, and logger name.

To use, just create and set the relevant object, as in the following: ::

  (setf (message-formatter *default-journal*) (make-instance 'json-meatadata-formatter))
  (setf (message-formatter *default-journal*) (make-instance 'json-simple-formatter))

You can also construct a logger and pass the ``:format`` initarg, as in: ::

  (make-instance 'stream-journal
     :name "grip"
     :threshold +info+
     :format (make-instance 'json-metadata-formatter)
     :output-target *standard-output)

Merged Output Targets
`````````````````````

The core ``merged-journal`` implementation provides support for a kind of
``tee``'d output pattern where the same log messages are dispatched to more
than one output target. Often it makes sense to send output to some kind of
centralized log storage system (perhaps on a buffer), while also mirroring
those messages locally in some form.

The method ``merge-journals`` will take any two journal implementations and
create a merged output. There implementations to support merging outputs into
an existing mergered journal, or merging two other journals.

Buffered Output
```````````````

The ``grip.ext.buffer`` package provides an output target that buffers
messages dispatched to an underlying sender for a defined interval or maximum
number of messages.  To use, create an instance as follows: ::

  (make-instance 'buffered-journal
     :journal (make-instance 'base-journal)
     :size 500
     :interval (local-time-duration:duration :sec 15))

The only required initform is ``journal``, size defaults to 100, and the
interval defaults to 10 seconds.

The implementation uses `chanl `_ to handle the
background processing, and is likely to perform poorly on particularly
low-volume workloads. Messages are sent to the journal wrapped in batches.

Batched Messages
````````````````

In the ``grip.message`` package there is a ``batch-message`` class, with the
accompanying ``merge-messages`` generic function that should make it possible
to combine groups of messages in a single "batch". There's fallback behavior
that will unwindind and "send" each of the constituent messages
individually. The implementations of ``merge-messages`` make batches easy to
construct: ::

  (merge-messages (make-message +info+ "one") (make-message +info+ "two"))

  (let ((batch (make-instance 'batch-message')))
     (merge-messages batch (make-message +info+ two)))

You can also use ``merge-messages`` to merge two batches (the messages from
the smaller batch are added to the larger batch,) and there are
implementations to passing the arguments in the opposite order.

The concept is that a batch of messages may make it easier for output
implementations to take advantage of bulk delivery methods, which are more
efficient at scale, particularly for output targets that might have some kind
of rate limiting. Internally, ``batch-messages`` are used by the
``buffered-journal``.

Extension
---------

Grip's design privileges extensibility and simple . Message formatting, line
formating, output targets, and even logger behavior should be easy to override
and customize. This section will cover what classes you need to create and
methods you should implement.

Output Targets
~~~~~~~~~~~~~~

To write log data to a different output:

- subclass ``grip.logger:base-journal``, to store the configuration and state
  of your logger, and

- specialize the generic function ``grip.logger:send-message`` to declare how
  messages would be delivered.

Consider the following implementation, from the tests tests for a logger that
just stores messages in a vector: ::

   (defclass in-memory-journal (base-journal)
     ((output-target
       :initform (make-array 0 :adjustable t :fill-pointer t)
       :reader output-target))
     (:documentation "a basic logger with similar semantics to the basic
     journals but that saves "))

   (defmethod send-message ((logger in-memory-journal) (msg grip.message:base-message))
     (when (loggable-p msg (threshold logger))
       (vector-push-extend msg (output-target logger))
       (format-message logger (message-formatter logger) msg)))

You can choose to specialize other methods, including ``format-message``,
which takes the logger as an argument, and any of the ``grip.logger`` logging
methods (e.g. those that end in ``>``,) but that is optional.

Message Formatting
~~~~~~~~~~~~~~~~~~

There are two formating and message processing stages, first the
``resolve-output`` message process the content or payload of the message,
while the ``format-message`` calls ``resolve-output`` and packages additional
information into message. In the default case, format-message is responsible
for adding the name of the logger, the timestamp, and the log level.

The ``base-journal`` implementation has a ``formater`` slot that holds a
message format configuration object, which is passed to both formatting
functions, so that loggers can configure how messages are output.

Development
-----------

Grip is available under the terms of the Apache v2 license.

Please feel free to create issues if you experience a problem or have a
feature request. Pull requests are particularly welcome and encouraged!

Workflow Suggestions
~~~~~~~~~~~~~~~~~~~~

- I suggest checking out this repository in your
  ``~/quicklisp/local-projects/`` directory (or equivalent). To run coverage
  tests you will want also make this available in
  `~/.roswell/local-projects/tychoish/cl-grip`` (I use symlinks for these
  operations.)

- To run tests, you can either run them interactively in SLIME, or use the
  ``make test`` target in the makefile. I prefer SLIME for interface for
  development purposes, but the makefile is useful for validating the tests in
  a clean environment.

- A ``make coverage`` target exists to produce a coverage report in
  ``report/cover-index.html`` directory. This target depends on having
  ``rove`` in the ``PATH`` which you can achieve by ``ros install
  fukamachi/rove``.

Guidelines
~~~~~~~~~~

In general, consider the following guidelines:

- grip aims to have full test coverage, particularly for the core system,
  although this isn't always practical. Do write tests! If you have trouble
  figuring out how to test a feature, or a change in a pull request, don't
  worry and we can work that out later.

- limit the number of dependencies in the core package. If you want to write a
  logger that

- grip uses a single package per file model. at this time, and attempts to
  limit the number of exported symbols per package.

While there is not a strong roadmap or timeline for grip, if you're interested
in contributing to grip but don't know where to start, the following
features or areas might be a good place to start:

- benchmarking: while the implementation is straight forward, it would be nice
  to know what kind of overhead the logging infrastructure takes, and some
  kind of benchmarking would be useful in determining the impact of changes.

- logging output targets. There are a number of potential logging/messaging
  output formats that could be interesting:

  - (ext) logging directly to splunk, probably using their HEC and some kind of
    message batching.

  - (ext) logging directly to the SumoLogic service, which should be broadly
    similar to splunk, but would require a separate implementation.

  - (ext) output implementations targeting "alerting workloads" including XMPP,
    slack, email, and webhook delivery.

- message handling improvements:

  - (core) extending the ``structured-message`` and ``make-message`` handlers
    to do better with additional input types.

  - (ext) improve the automatic metadata collection and population for
    structured messages, both during message collection and also by
    configuring formatters.

  - (core) provide easier helpers for creating arbitrary structured
    messages. Perhaps a ``with-message`` macro or similar.

  - (ext) message implementations and tooling that collect data about the
    application state.

- implementation of a stream object which wraps a logger implementation, using
  `trivial gray streams `_
  to facilitate using a logger in APIs that rely on a stream (like output of a
  file.)


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 cl-grip

Author

Sam Kleinman <sam@tychoish.com>

License

Apache v2

Description

Grip is a simple logging interface and framework. The core package contains basic infrastructure and interfaces.

Version

0.0.1

Dependencies
Source

cl-grip.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 cl-grip/src

Parent

cl-grip (system)

Location

src/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 cl-grip.asd

Location

cl-grip.asd

Systems

cl-grip (system)


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

4.1.2 cl-grip/src/level.lisp

Parent

src (module)

Location

src/level.lisp

Packages

grip.level

Exported Definitions
Internal Definitions

string-for-level (function)


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

4.1.3 cl-grip/src/message.lisp

Dependency

level.lisp (file)

Parent

src (module)

Location

src/message.lisp

Packages

grip.message

Exported Definitions
Internal Definitions

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

4.1.4 cl-grip/src/logger.lisp

Dependencies
Parent

src (module)

Location

src/logger.lisp

Packages

grip.logger

Exported Definitions

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

4.1.5 cl-grip/src/grip.lisp

Dependencies
Parent

src (module)

Location

src/grip.lisp

Packages

grip

Exported Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 grip.level

Source

level.lisp (file)

Use List

common-lisp

Used By List

grip.message

Exported Definitions
Internal Definitions

string-for-level (function)


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

5.2 grip.message

Source

message.lisp (file)

Use List
Used By List

grip.logger

Exported Definitions
Internal Definitions

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

5.3 grip.logger

Logger contains basic implementation of logging
implementations ’journal’ with limited external dependencies, and related interface.

Source

logger.lisp (file)

Use List
Exported Definitions

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

5.4 grip

Source

grip.lisp (file)

Use List

common-lisp

Exported Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Special variables

Special Variable: *default-logger*

default package logger, should not be exported

Package

grip

Source

grip.lisp (file)

Special Variable: +alert+
Package

grip.level

Source

level.lisp (file)

Special Variable: +critical+
Package

grip.level

Source

level.lisp (file)

Special Variable: +debug+
Package

grip.level

Source

level.lisp (file)

Special Variable: +emergency+
Package

grip.level

Source

level.lisp (file)

Special Variable: +error+
Package

grip.level

Source

level.lisp (file)

Special Variable: +info+
Package

grip.level

Source

level.lisp (file)

Special Variable: +notice+
Package

grip.level

Source

level.lisp (file)

Special Variable: +trace+
Package

grip.level

Source

level.lisp (file)

Special Variable: +warning+
Package

grip.level

Source

level.lisp (file)


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

6.1.2 Functions

Function: alert> MSG
Package

grip

Source

grip.lisp (file)

Function: critical> MSG
Package

grip

Source

grip.lisp (file)

Function: debug> MSG
Package

grip

Source

grip.lisp (file)

Function: emergency> MSG
Package

grip

Source

grip.lisp (file)

Function: error> MSG
Package

grip

Source

grip.lisp (file)

Function: info> MSG
Package

grip

Source

grip.lisp (file)

Function: log> LEVEL MESSAGE
Package

grip

Source

grip.lisp (file)

Function: make-priority VALUE
Package

grip.level

Source

level.lisp (file)

Function: new-message INPUT &key ARGS LEVEL (WHEN CONDITIONAL)

Constructs a new message from an input type, with optional parameters:

LEVEL: sets the level of the message that’s created, defaulting to debug.

WHEN: sets the conditional flag, making it possible to avoid wrapping log statements in conditionals, to render a log statement un-loggable.

ARGS: When the input is a string and args, this will produce a message that is roughly equivalent to ’sprintf’ in other languages, though this implementation caches the string (for multi-output reuse) and supports both the ’format’ macro’s syntax when the args list is a proper list, or a double-bracketed token form when the the args list is an alist.

Package

grip.message

Source

message.lisp (file)

Function: notice> MSG
Package

grip

Source

grip.lisp (file)

Function: trace> MSG
Package

grip

Source

grip.lisp (file)

Function: warning> MSG
Package

grip

Source

grip.lisp (file)


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

6.1.3 Generic functions

Generic Function: alert> LOGGER MESSAGE

Sends the message to a logger at level
’alert’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: alert> LOGGER MESSAGE
Generic Function: critical> LOGGER MESSAGE

Sends the message to a logger at level
’alert’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: critical> LOGGER MESSAGE
Generic Function: debug> LOGGER MESSAGE

Sends the message to a logger at level
’debug’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: debug> LOGGER MESSAGE
Generic Function: emergency> LOGGER MESSAGE

Sends the message to a logger at level
’emergency’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: emergency> LOGGER MESSAGE
Generic Function: error> LOGGER MESSAGE

Sends the message to a logger at level
’debug’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: error> LOGGER MESSAGE
Generic Function: export-message MESSAGE

Tmplement export-message to support messages which can convert themselves into message objects.

Package

grip.message

Source

message.lisp (file)

Generic Function: format-message LOGGER FORMATTER MESSAGE

implement format-message to control message output

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: format-message (LOGGER base-journal) (FMT basic-formatter) (MSG base-message)
Method: format-message LOGGER (FMT format-config) (MSG base-message)
Generic Function: format-timestamp OBJECT
Generic Function: (setf format-timestamp) NEW-VALUE OBJECT
Package

grip.message

Methods
Method: format-timestamp (BASIC-FORMATTER basic-formatter)

automatically generated reader method

Source

message.lisp (file)

Method: (setf format-timestamp) NEW-VALUE (BASIC-FORMATTER basic-formatter)

automatically generated writer method

Source

message.lisp (file)

Generic Function: info> LOGGER MESSAGE

Sends the message to a logger at level ’info’. This
functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: info> LOGGER MESSAGE
Generic Function: log> LOGGER LEVEL MESSAGE

provides a basic shim between send-message and
logging methods and makes it possible to deliver messages to different log levels.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: log> LOGGER LEVEL MESSAGE
Generic Function: loggable-p MESSAGE THRESHOLD-LEVEL

test if a message is logable

Package

grip.message

Source

message.lisp (file)

Methods
Method: loggable-p (MESSAGE batch-message) (THRESHOLD priority)
Method: loggable-p (MESSAGE sprintf-message) (THRESHOLD priority)
Method: loggable-p (MESSAGE simple-message) (THRESHOLD priority)
Method: loggable-p (MESSAGE structured-message) (THRESHOLD priority)
Method: loggable-p (MESSAGE base-message) (THRESHOLD priority) around
Generic Function: make-message LEVEL MESSAGE

method to convert an arbitrary type to a message implementation

Package

grip.message

Source

message.lisp (file)

Methods
Method: make-message (PRI priority) INPUT
Method: make-message (PRI priority) (MSG base-message)
Generic Function: merge-journals JOURNAL-ONE JOURNAL-TWO

takes two journals and combines or merges them into a single stream, as best as possible

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: merge-journals (BASE merged-journal) (LOGGER base-journal)
Method: merge-journals (FIRST base-journal) (SECOND base-journal)
Method: merge-journals (SECOND base-journal) (BASE merged-journal)
Method: merge-journals (BASE merged-journal) (SECOND merged-journal)
Generic Function: merge-messages MESSAGE1 MESSAGE2

combines one or more messages into a batch message
returning the message. If one or both of the messages is already a batch message then the constituent messages are produced.

Package

grip.message

Source

message.lisp (file)

Methods
Method: merge-messages (ONE batch-message) (TWO batch-message)
Method: merge-messages (MESSAGE base-message) (BATCH batch-message)
Method: merge-messages (ONE base-message) (TWO base-message)
Method: merge-messages (BATCH batch-message) (MESSAGE base-message)
Generic Function: message-batch OBJECT
Generic Function: (setf message-batch) NEW-VALUE OBJECT
Package

grip.message

Methods
Method: message-batch (BATCH-MESSAGE batch-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-batch) NEW-VALUE (BATCH-MESSAGE batch-message)

automatically generated writer method

Source

message.lisp (file)

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

grip.message

Methods
Method: message-conditional (BASE-MESSAGE base-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-conditional) NEW-VALUE (BASE-MESSAGE base-message)

automatically generated writer method

Source

message.lisp (file)

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

grip.logger

Methods
Method: message-formatter (BASE-JOURNAL base-journal)

automatically generated reader method

Source

logger.lisp (file)

Method: (setf message-formatter) NEW-VALUE (BASE-JOURNAL base-journal)

automatically generated writer method

Source

logger.lisp (file)

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

grip.message

Methods
Method: message-level (BASE-MESSAGE base-message)

automatically generated reader method

Source

message.lisp (file)

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

automatically generated writer method

Source

message.lisp (file)

Method: (setf message-level) LEVEL (BATCH batch-message)
Source

message.lisp (file)

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

grip.message

Methods
Method: message-payload (SPRINTF-MESSAGE sprintf-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-payload) NEW-VALUE (SPRINTF-MESSAGE sprintf-message)

automatically generated writer method

Source

message.lisp (file)

Method: message-payload (SIMPLE-MESSAGE simple-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-payload) NEW-VALUE (SIMPLE-MESSAGE simple-message)

automatically generated writer method

Source

message.lisp (file)

Method: message-payload (STRUCTURED-MESSAGE structured-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-payload) NEW-VALUE (STRUCTURED-MESSAGE structured-message)

automatically generated writer method

Source

message.lisp (file)

Generic Function: message-timestamp OBJECT
Package

grip.message

Methods
Method: message-timestamp (BASE-MESSAGE base-message)

automatically generated reader method

Source

message.lisp (file)

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

grip.logger

Methods
Method: name (BASE-JOURNAL base-journal)

automatically generated reader method

Source

logger.lisp (file)

Method: (setf name) NEW-VALUE (BASE-JOURNAL base-journal)

automatically generated writer method

Source

logger.lisp (file)

Generic Function: notice> LOGGER MESSAGE

Sends the message to a logger at level
’notice’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: notice> LOGGER MESSAGE
Generic Function: output-target OBJECT
Generic Function: (setf output-target) NEW-VALUE OBJECT
Package

grip.logger

Methods
Method: output-target (MERGED-JOURNAL merged-journal)

automatically generated reader method

Source

logger.lisp (file)

Method: (setf output-target) NEW-VALUE (MERGED-JOURNAL merged-journal)

automatically generated writer method

Source

logger.lisp (file)

Method: output-target (STREAM-JOURNAL stream-journal)

automatically generated reader method

Source

logger.lisp (file)

Method: (setf output-target) NEW-VALUE (STREAM-JOURNAL stream-journal)

automatically generated writer method

Source

logger.lisp (file)

Generic Function: priority-string PRIORITY

returns the name of a priority level

Package

grip.level

Source

level.lisp (file)

Methods
Method: priority-string (LEVEL priority)
Generic Function: priority-value OBJECT
Package

grip.level

Methods
Method: priority-value (PRIORITY priority)

automatically generated reader method

Source

level.lisp (file)

Generic Function: priority>= LEVEL THRESHOLD

implements a greater than or equal to comparison
for priority objects, as well as comparisons between numbers priority objects.

Package

grip.level

Source

level.lisp (file)

Methods
Method: priority>= (LEVEL priority) (THRESHOLD number)
Method: priority>= (LEVEL number) (THRESHOLD priority)
Method: priority>= (LEVEL priority) (THRESHOLD priority)
Generic Function: resolve-output FORMATER MESSAGE

should produce a formatted string with data for
human consumption in logging output. This should only include the message’s string form and payload content, other preparation of the message, including metadata should be handled by ’format-message’

Package

grip.message

Source

message.lisp (file)

Methods
Method: resolve-output FORMATER (MESSAGE structured-message)
Method: resolve-output FORMATER (MESSAGE simple-message)
Method: resolve-output FORMATTER (MESSAGE sprintf-message)
Generic Function: send-message LOGGER MESSAGE

fundamental mesage sending method.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: send-message (LOGGER merged-journal) (MSG base-message)
Method: send-message LOGGER (BATCH batch-message) around
Method: send-message (LOGGER base-journal) (MSG base-message)
Method: send-message (LOGGER stream-journal) (MSG base-message)
Generic Function: threshold OBJECT
Generic Function: (setf threshold) NEW-VALUE OBJECT
Package

grip.logger

Methods
Method: threshold (BASE-JOURNAL base-journal)

automatically generated reader method

Source

logger.lisp (file)

Method: (setf threshold) NEW-VALUE (BASE-JOURNAL base-journal)

automatically generated writer method

Source

logger.lisp (file)

Generic Function: trace> LOGGER MESSAGE

Sends the message to a logger at level
’trace’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: trace> LOGGER MESSAGE
Generic Function: warning> LOGGER MESSAGE

Sends the message to a logger at level
’warning’. This functionality is provided as a generic method to make it possible to extend or override for some logging implementations. The default implementation wraps ’log’.

Package

grip.logger

Source

logger.lisp (file)

Methods
Method: warning> LOGGER MESSAGE

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

6.1.4 Classes

Class: base-journal ()

a basic implementation of a journal logger, that
can be used as the super-class of most or all journal implementations. Generally subclasses only need to implement send-message

Package

grip.logger

Source

logger.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

string

Initargs

:name

Initform

"grip"

Readers

name (generic function)

Writers

(setf name) (generic function)

Slot: threshold
Type

grip.level:priority

Initargs

:threshold

Initform

grip.level:+info+

Readers

threshold (generic function)

Writers

(setf threshold) (generic function)

Slot: formatter
Type

grip.message:format-config

Initargs

:format

Initform

(make-instance (quote grip.message:basic-formatter))

Readers

message-formatter (generic function)

Writers

(setf message-formatter) (generic function)

Class: base-message ()

basic message is a complete implementation of the
message protocol, and is the primary form for all messages. To log arbitrary types, either convert them to a base-message subclass by implementing ’export-message’ method, or implement ’export-message’ or ’make-message’ as well as ’send-message’. In most cases, ’send-message’ implementations should generally rely on the ’format-message’, ’resolve-output’ and ’loggable-p’ methods.

Package

grip.message

Source

message.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: conditional
Type

boolean

Initargs

:when

Initform

t

Readers

message-conditional (generic function)

Writers

(setf message-conditional) (generic function)

Slot: timestamp
Type

local-time:timestamp

Initform

(local-time:now)

Readers

message-timestamp (generic function)

Slot: level
Type

grip.level:priority

Initargs

:level

Initform

grip.level:+trace+

Readers

message-level (generic function)

Writers

(setf message-level) (generic function)

Class: basic-formatter ()

a holder for configuration, composed by the journal implementation to allow pluggable message formatting.

Package

grip.message

Source

message.lisp (file)

Direct superclasses

format-config (class)

Direct methods
Direct slots
Slot: timestamp
Initargs

:timestamp

Initform

(quote (:year #\/ (:month 2) #\/ (:day 2) #\ (:hour 2) #\: (:min 2) #\: (:sec 2)))

Readers

format-timestamp (generic function)

Writers

(setf format-timestamp) (generic function)

Class: batch-message ()

batch message provides an implementation of
messages that holds a group of message objects rather than a single message.

Package

grip.message

Source

message.lisp (file)

Direct superclasses

base-message (class)

Direct methods
Direct slots
Slot: batch
Initform

(make-array 2 :adjustable t :fill-pointer 0)

Readers

message-batch (generic function)

Writers

(setf message-batch) (generic function)

Class: format-config ()

the basic formater class serves as the root class
for all formater implementations and provides a simple ’plain’ formating output.

Package

grip.message

Source

message.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

basic-formatter (class)

Direct methods

format-message (method)

Class: merged-journal ()

a journal implementation that dispatches messages to more than one output for every message sent

Package

grip.logger

Source

logger.lisp (file)

Direct superclasses

base-journal (class)

Direct methods
Direct slots
Slot: output-target
Initform

(make-array 0 :element-type (quote grip.logger:base-journal) :adjustable t :fill-pointer 0)

Readers

output-target (generic function)

Writers

(setf output-target) (generic function)

Class: priority ()

defines a log level or priority to be associated with messages

Package

grip.level

Source

level.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: value
Type

integer

Initargs

:value

Readers

priority-value (generic function)

Class: simple-message ()

Simple messages just wrap a single string.

Package

grip.message

Source

message.lisp (file)

Direct superclasses

base-message (class)

Direct methods
Direct slots
Slot: description
Type

string

Initargs

:payload

Initform

""

Readers

message-payload (generic function)

Writers

(setf message-payload) (generic function)

Class: sprintf-message ()
Package

grip.message

Source

message.lisp (file)

Direct superclasses

base-message (class)

Direct methods
Direct slots
Slot: cache
Initargs

:payload

Readers

message-payload (generic function)

Writers

(setf message-payload) (generic function)

Slot: template
Type

string

Initargs

:base

Initform

""

Readers

message-sprintf-template (generic function)

Writers

(setf message-sprintf-template) (generic function)

Slot: args
Type

list

Initargs

:args

Readers

message-sprintf-args (generic function)

Writers

(setf message-sprintf-args) (generic function)

Class: stream-journal ()

a simple logger that writes to a specific stream

Package

grip.logger

Source

logger.lisp (file)

Direct superclasses

base-journal (class)

Direct methods
Direct slots
Slot: output-target
Type

stream

Initargs

:output-target

Initform

*standard-output*

Readers

output-target (generic function)

Writers

(setf output-target) (generic function)

Class: structured-message ()

Structured messages are those which wrap alist, plist, hash-maps.

Package

grip.message

Source

message.lisp (file)

Direct superclasses

base-message (class)

Direct methods
Direct slots
Slot: data
Initargs

:payload

Readers

message-payload (generic function)

Writers

(setf message-payload) (generic function)


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

6.2 Internal definitions


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

6.2.1 Functions

Function: export-message-p MESSAGE

Returns true if the message object implements has an applicable message implementation.

Package

grip.message

Source

message.lisp (file)

Function: sprintf TMPL ARGS
Package

grip.message

Source

message.lisp (file)

Function: string-for-level VALUE
Package

grip.level

Source

level.lisp (file)


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

6.2.2 Generic functions

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

grip.message

Methods
Method: message-sprintf-args (SPRINTF-MESSAGE sprintf-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-sprintf-args) NEW-VALUE (SPRINTF-MESSAGE sprintf-message)

automatically generated writer method

Source

message.lisp (file)

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

grip.message

Methods
Method: message-sprintf-template (SPRINTF-MESSAGE sprintf-message)

automatically generated reader method

Source

message.lisp (file)

Method: (setf message-sprintf-template) NEW-VALUE (SPRINTF-MESSAGE sprintf-message)

automatically generated writer method

Source

message.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
cl-grip.asd: The cl-grip․asd file
cl-grip/src: The cl-grip/src module
cl-grip/src/grip.lisp: The cl-grip/src/grip․lisp file
cl-grip/src/level.lisp: The cl-grip/src/level․lisp file
cl-grip/src/logger.lisp: The cl-grip/src/logger․lisp file
cl-grip/src/message.lisp: The cl-grip/src/message․lisp file

F
File, Lisp, cl-grip.asd: The cl-grip․asd file
File, Lisp, cl-grip/src/grip.lisp: The cl-grip/src/grip․lisp file
File, Lisp, cl-grip/src/level.lisp: The cl-grip/src/level․lisp file
File, Lisp, cl-grip/src/logger.lisp: The cl-grip/src/logger․lisp file
File, Lisp, cl-grip/src/message.lisp: The cl-grip/src/message․lisp file

L
Lisp File, cl-grip.asd: The cl-grip․asd file
Lisp File, cl-grip/src/grip.lisp: The cl-grip/src/grip․lisp file
Lisp File, cl-grip/src/level.lisp: The cl-grip/src/level․lisp file
Lisp File, cl-grip/src/logger.lisp: The cl-grip/src/logger․lisp file
Lisp File, cl-grip/src/message.lisp: The cl-grip/src/message․lisp file

M
Module, cl-grip/src: The cl-grip/src module

Jump to:   C   F   L   M  

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

A.2 Functions

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

(
(setf format-timestamp): Exported generic functions
(setf format-timestamp): Exported generic functions
(setf message-batch): Exported generic functions
(setf message-batch): Exported generic functions
(setf message-conditional): Exported generic functions
(setf message-conditional): Exported generic functions
(setf message-formatter): Exported generic functions
(setf message-formatter): Exported generic functions
(setf message-level): Exported generic functions
(setf message-level): Exported generic functions
(setf message-level): Exported generic functions
(setf message-payload): Exported generic functions
(setf message-payload): Exported generic functions
(setf message-payload): Exported generic functions
(setf message-payload): Exported generic functions
(setf message-sprintf-args): Internal generic functions
(setf message-sprintf-args): Internal generic functions
(setf message-sprintf-template): Internal generic functions
(setf message-sprintf-template): Internal generic functions
(setf name): Exported generic functions
(setf name): Exported generic functions
(setf output-target): Exported generic functions
(setf output-target): Exported generic functions
(setf output-target): Exported generic functions
(setf threshold): Exported generic functions
(setf threshold): Exported generic functions

A
alert>: Exported functions
alert>: Exported generic functions
alert>: Exported generic functions

C
critical>: Exported functions
critical>: Exported generic functions
critical>: Exported generic functions

D
debug>: Exported functions
debug>: Exported generic functions
debug>: Exported generic functions

E
emergency>: Exported functions
emergency>: Exported generic functions
emergency>: Exported generic functions
error>: Exported functions
error>: Exported generic functions
error>: Exported generic functions
export-message: Exported generic functions
export-message-p: Internal functions

F
format-message: Exported generic functions
format-message: Exported generic functions
format-message: Exported generic functions
format-timestamp: Exported generic functions
format-timestamp: Exported generic functions
Function, alert>: Exported functions
Function, critical>: Exported functions
Function, debug>: Exported functions
Function, emergency>: Exported functions
Function, error>: Exported functions
Function, export-message-p: Internal functions
Function, info>: Exported functions
Function, log>: Exported functions
Function, make-priority: Exported functions
Function, new-message: Exported functions
Function, notice>: Exported functions
Function, sprintf: Internal functions
Function, string-for-level: Internal functions
Function, trace>: Exported functions
Function, warning>: Exported functions

G
Generic Function, (setf format-timestamp): Exported generic functions
Generic Function, (setf message-batch): Exported generic functions
Generic Function, (setf message-conditional): Exported generic functions
Generic Function, (setf message-formatter): Exported generic functions
Generic Function, (setf message-level): Exported generic functions
Generic Function, (setf message-payload): Exported generic functions
Generic Function, (setf message-sprintf-args): Internal generic functions
Generic Function, (setf message-sprintf-template): Internal generic functions
Generic Function, (setf name): Exported generic functions
Generic Function, (setf output-target): Exported generic functions
Generic Function, (setf threshold): Exported generic functions
Generic Function, alert>: Exported generic functions
Generic Function, critical>: Exported generic functions
Generic Function, debug>: Exported generic functions
Generic Function, emergency>: Exported generic functions
Generic Function, error>: Exported generic functions
Generic Function, export-message: Exported generic functions
Generic Function, format-message: Exported generic functions
Generic Function, format-timestamp: Exported generic functions
Generic Function, info>: Exported generic functions
Generic Function, log>: Exported generic functions
Generic Function, loggable-p: Exported generic functions
Generic Function, make-message: Exported generic functions
Generic Function, merge-journals: Exported generic functions
Generic Function, merge-messages: Exported generic functions
Generic Function, message-batch: Exported generic functions
Generic Function, message-conditional: Exported generic functions
Generic Function, message-formatter: Exported generic functions
Generic Function, message-level: Exported generic functions
Generic Function, message-payload: Exported generic functions
Generic Function, message-sprintf-args: Internal generic functions
Generic Function, message-sprintf-template: Internal generic functions
Generic Function, message-timestamp: Exported generic functions
Generic Function, name: Exported generic functions
Generic Function, notice>: Exported generic functions
Generic Function, output-target: Exported generic functions
Generic Function, priority-string: Exported generic functions
Generic Function, priority-value: Exported generic functions
Generic Function, priority>=: Exported generic functions
Generic Function, resolve-output: Exported generic functions
Generic Function, send-message: Exported generic functions
Generic Function, threshold: Exported generic functions
Generic Function, trace>: Exported generic functions
Generic Function, warning>: Exported generic functions

I
info>: Exported functions
info>: Exported generic functions
info>: Exported generic functions

L
log>: Exported functions
log>: Exported generic functions
log>: Exported generic functions
loggable-p: Exported generic functions
loggable-p: Exported generic functions
loggable-p: Exported generic functions
loggable-p: Exported generic functions
loggable-p: Exported generic functions
loggable-p: Exported generic functions

M
make-message: Exported generic functions
make-message: Exported generic functions
make-message: Exported generic functions
make-priority: Exported functions
merge-journals: Exported generic functions
merge-journals: Exported generic functions
merge-journals: Exported generic functions
merge-journals: Exported generic functions
merge-journals: Exported generic functions
merge-messages: Exported generic functions
merge-messages: Exported generic functions
merge-messages: Exported generic functions
merge-messages: Exported generic functions
merge-messages: Exported generic functions
message-batch: Exported generic functions
message-batch: Exported generic functions
message-conditional: Exported generic functions
message-conditional: Exported generic functions
message-formatter: Exported generic functions
message-formatter: Exported generic functions
message-level: Exported generic functions
message-level: Exported generic functions
message-payload: Exported generic functions
message-payload: Exported generic functions
message-payload: Exported generic functions
message-payload: Exported generic functions
message-sprintf-args: Internal generic functions
message-sprintf-args: Internal generic functions
message-sprintf-template: Internal generic functions
message-sprintf-template: Internal generic functions
message-timestamp: Exported generic functions
message-timestamp: Exported generic functions
Method, (setf format-timestamp): Exported generic functions
Method, (setf message-batch): Exported generic functions
Method, (setf message-conditional): Exported generic functions
Method, (setf message-formatter): Exported generic functions
Method, (setf message-level): Exported generic functions
Method, (setf message-level): Exported generic functions
Method, (setf message-payload): Exported generic functions
Method, (setf message-payload): Exported generic functions
Method, (setf message-payload): Exported generic functions
Method, (setf message-sprintf-args): Internal generic functions
Method, (setf message-sprintf-template): Internal generic functions
Method, (setf name): Exported generic functions
Method, (setf output-target): Exported generic functions
Method, (setf output-target): Exported generic functions
Method, (setf threshold): Exported generic functions
Method, alert>: Exported generic functions
Method, critical>: Exported generic functions
Method, debug>: Exported generic functions
Method, emergency>: Exported generic functions
Method, error>: Exported generic functions
Method, format-message: Exported generic functions
Method, format-message: Exported generic functions
Method, format-timestamp: Exported generic functions
Method, info>: Exported generic functions
Method, log>: Exported generic functions
Method, loggable-p: Exported generic functions
Method, loggable-p: Exported generic functions
Method, loggable-p: Exported generic functions
Method, loggable-p: Exported generic functions
Method, loggable-p: Exported generic functions
Method, make-message: Exported generic functions
Method, make-message: Exported generic functions
Method, merge-journals: Exported generic functions
Method, merge-journals: Exported generic functions
Method, merge-journals: Exported generic functions
Method, merge-journals: Exported generic functions
Method, merge-messages: Exported generic functions
Method, merge-messages: Exported generic functions
Method, merge-messages: Exported generic functions
Method, merge-messages: Exported generic functions
Method, message-batch: Exported generic functions
Method, message-conditional: Exported generic functions
Method, message-formatter: Exported generic functions
Method, message-level: Exported generic functions
Method, message-payload: Exported generic functions
Method, message-payload: Exported generic functions
Method, message-payload: Exported generic functions
Method, message-sprintf-args: Internal generic functions
Method, message-sprintf-template: Internal generic functions
Method, message-timestamp: Exported generic functions
Method, name: Exported generic functions
Method, notice>: Exported generic functions
Method, output-target: Exported generic functions
Method, output-target: Exported generic functions
Method, priority-string: Exported generic functions
Method, priority-value: Exported generic functions
Method, priority>=: Exported generic functions
Method, priority>=: Exported generic functions
Method, priority>=: Exported generic functions
Method, resolve-output: Exported generic functions
Method, resolve-output: Exported generic functions
Method, resolve-output: Exported generic functions
Method, send-message: Exported generic functions
Method, send-message: Exported generic functions
Method, send-message: Exported generic functions
Method, send-message: Exported generic functions
Method, threshold: Exported generic functions
Method, trace>: Exported generic functions
Method, warning>: Exported generic functions

N
name: Exported generic functions
name: Exported generic functions
new-message: Exported functions
notice>: Exported functions
notice>: Exported generic functions
notice>: Exported generic functions

O
output-target: Exported generic functions
output-target: Exported generic functions
output-target: Exported generic functions

P
priority-string: Exported generic functions
priority-string: Exported generic functions
priority-value: Exported generic functions
priority-value: Exported generic functions
priority>=: Exported generic functions
priority>=: Exported generic functions
priority>=: Exported generic functions
priority>=: Exported generic functions

R
resolve-output: Exported generic functions
resolve-output: Exported generic functions
resolve-output: Exported generic functions
resolve-output: Exported generic functions

S
send-message: Exported generic functions
send-message: Exported generic functions
send-message: Exported generic functions
send-message: Exported generic functions
send-message: Exported generic functions
sprintf: Internal functions
string-for-level: Internal functions

T
threshold: Exported generic functions
threshold: Exported generic functions
trace>: Exported functions
trace>: Exported generic functions
trace>: Exported generic functions

W
warning>: Exported functions
warning>: Exported generic functions
warning>: Exported generic functions

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

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

A.3 Variables

Jump to:   *   +  
A   B   C   D   F   L   N   O   S   T   V  
Index Entry  Section

*
*default-logger*: Exported special variables

+
+alert+: Exported special variables
+critical+: Exported special variables
+debug+: Exported special variables
+emergency+: Exported special variables
+error+: Exported special variables
+info+: Exported special variables
+notice+: Exported special variables
+trace+: Exported special variables
+warning+: Exported special variables

A
args: Exported classes

B
batch: Exported classes

C
cache: Exported classes
conditional: Exported classes

D
data: Exported classes
description: Exported classes

F
formatter: Exported classes

L
level: Exported classes

N
name: Exported classes

O
output-target: Exported classes
output-target: Exported classes

S
Slot, args: Exported classes
Slot, batch: Exported classes
Slot, cache: Exported classes
Slot, conditional: Exported classes
Slot, data: Exported classes
Slot, description: Exported classes
Slot, formatter: Exported classes
Slot, level: Exported classes
Slot, name: Exported classes
Slot, output-target: Exported classes
Slot, output-target: Exported classes
Slot, template: Exported classes
Slot, threshold: Exported classes
Slot, timestamp: Exported classes
Slot, timestamp: Exported classes
Slot, value: Exported classes
Special Variable, *default-logger*: Exported special variables
Special Variable, +alert+: Exported special variables
Special Variable, +critical+: Exported special variables
Special Variable, +debug+: Exported special variables
Special Variable, +emergency+: Exported special variables
Special Variable, +error+: Exported special variables
Special Variable, +info+: Exported special variables
Special Variable, +notice+: Exported special variables
Special Variable, +trace+: Exported special variables
Special Variable, +warning+: Exported special variables

T
template: Exported classes
threshold: Exported classes
timestamp: Exported classes
timestamp: Exported classes

V
value: Exported classes

Jump to:   *   +  
A   B   C   D   F   L   N   O   S   T   V  

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

A.4 Data types

Jump to:   B   C   F   G   M   P   S  
Index Entry  Section

B
base-journal: Exported classes
base-message: Exported classes
basic-formatter: Exported classes
batch-message: Exported classes

C
cl-grip: The cl-grip system
Class, base-journal: Exported classes
Class, base-message: Exported classes
Class, basic-formatter: Exported classes
Class, batch-message: Exported classes
Class, format-config: Exported classes
Class, merged-journal: Exported classes
Class, priority: Exported classes
Class, simple-message: Exported classes
Class, sprintf-message: Exported classes
Class, stream-journal: Exported classes
Class, structured-message: Exported classes

F
format-config: Exported classes

G
grip: The grip package
grip.level: The grip․level package
grip.logger: The grip․logger package
grip.message: The grip․message package

M
merged-journal: Exported classes

P
Package, grip: The grip package
Package, grip.level: The grip․level package
Package, grip.logger: The grip․logger package
Package, grip.message: The grip․message package
priority: Exported classes

S
simple-message: Exported classes
sprintf-message: Exported classes
stream-journal: Exported classes
structured-message: Exported classes
System, cl-grip: The cl-grip system

Jump to:   B   C   F   G   M   P   S