The logger module

The logger module contains the LogLevel, Logger, FileLogger, and LogData classes.

These classes are focused on logging system output to various types of output streams (e.g., console, or a file), as well as logging messages at various different log levels.

The SingleLogger class

class pyamp.logging.logger.SingleLogger

The SingleLogger class implements the pyamp.patterns.Borg design pattern for creating a single system wide Logger object.

This allows an entire system to access the same Logger object so that each component can log messages with the same data (e.g., log level, color, prefix, etc).

Create the SingleLogger object.

classmethod createFileLogger(logFile, append=False, logLevel=30)

Create a system-wide FileLogger object.

• logFile – The log file to use
• append – True to append to the file, False to overwrite
• logLevel – The log level for the logger

classmethod createLogger(name, logLevel=30)

Create a system-wide Logger object.

• name – The name of Logger
• logLevel – The log level for the logger

classmethod critical(message)

Log the given critical message.

• message – The message to log

classmethod debug(message)

Log the given debug message.

• message – The message to log

classmethod error(message)

Log the given error message.

• message – The message to log

classmethod fatal(message)

Log the given fatal message.

• message – The message to log

classmethod getInstance()

Get the instance of the Logger object.

classmethod info(message)

Log the given information message.

• message – The message to log

classmethod log(logLevel, message)

Log the given message at the given log level.

• logLevel – The log level
• message – The message to log

classmethod warn(message)

Log the given warning message.

• message – The message to log

classmethod warning(message)

Log the given warning message.

• message – The message to log

classmethod write(message)

Write an information message to the logger.

• message – The message to write

The LogLevel class

class pyamp.logging.logger.LogLevel

The LogLevel class contains definitions of all of the various log levels that can be used for logging messages. These levels are designed to make it easier to parse the output of a system to find different types of issues that were encountered at runtime.

• DEBUG – The debugging log level. Has a value of 10.
• INFO – The information log level. Has a value of 20.
• WARN – The warning log level. Has a value of 30.
• WARNING – The warning log level. Has a value of 30.
• ERROR – The error log level. Has a value of 40.
• CRITICAL – The critical log level. Has a value of 50.
• FATAL – The fatal log level. Has a value of 50.

The Prefix class

class pyamp.logging.logger.Prefix(text=None, color=0, prefix=None)

The Prefix class provides the ability to add chain of prefixes to a message. A Prefix contains text which is printed in square brackets before the given message. The following shows an example of the a Prefix for the string “DEBUG”.

Example:

prefix = Prefix(text="DEBUG")

# Prints: [DEBUG]: This is the message
prefix.apply("This is the message")

A Prefix can be colored, and it can contain other prefixes which are appended to the message before adding the current Prefix.

An example of multiple prefixes:

debugPrefix = Prefix(text="DEBUG")
examplePrefix = Prefix(text="example", prefix=debugPrefix)
datePrefix = Prefix(text="03/11/2012", prefix=examplePrefix)

# Prints: [DEBUG]: [example]: [03/11/2012]: This is the message
datePrefix.apply("This is the message")

• text – The text to display in the Prefix
• color – The color in which the Prefix will be displayed
• prefix – The next Prefix in the chain

apply(message, useColors=False)

Apply the chain of Prefixes to the given message.

• message – The message to apply the Prefix chain to
• useColors – True to use colors, False otherwise

The LogData class

class pyamp.logging.logger.LogData(logLevel=20, debugLevel=0)

The LogData class provides the ability to store logging data for an entire system in an object that can be easily handled.

The LogData class stores a LogLevel and an integer debug level for a system, and provides the ability to create a named Logger from the stored values.

For example:

# Any Logger objects created from this LogData object will have a
# LogLevel of DEBUG, and a debug level of 10.
logData = LogData(LogLevel.DEBUG, 10)

# Create a logger named 'ExampleLogger' which will log messages
# with a red foreground color.
logger = logData.get("ExampleLogger", Colors.Foreground.Red)

# This message will be displayed
logger.debug("Example message", 2)

# This message will not be displayed
logger.debug("Example message", 11)

LogData objects can be easily passed around which allows the :class::LogLevel and debug level values to be easily propagated throughout the system, rather than having individual values for each system component.

• logLevel – The log level
• debugLevel – The debug level

get(name=None, color=0)

Get a new Logger with the given name.

• name – The name to assign the Logger
• color – The color to use for the Logger

The Colors class

class pyamp.logging.logger.Colors

The Colors class contains two classes which define possible Foreground and Background colors. These colors can be used to colorize console output in a specific way.

class Background

The Background class contains definitions of the following background colors.

• White_Bold_Underline
• Blue, and Light_Blue
• Purple, and Light_Purple
• Green, and Light_Green
• Red, and Light_Red
• Gray, and Light_Gray
• Cyan, and Light_Cyan
• Orange, and Light_Yellow

class Colors.Foreground

The Foreground class contains definitions of the following foreground colors.

• White
• White_Bold
• White_Underline
• Black
• Blue, and Light_Blue
• Purple, and Light_Purple
• Green, and Light_Green
• Red, and Light_Red
• Gray, and Light_Gray
• Cyan, and Light_Cyan
• Orange, and Light_Yellow

The FileLogger class

class pyamp.logging.logger.FileLogger(filename, append=True, name=None, prefix=<pyamp.logging.prefix.Prefix instance at 0xa2ddd4c>, logLevel=30)

The FileLogger class provides a wrapper class for a Logger object which outputs its messages to a specified file. When creating the FileLogger, it can be specified whether existing files should be overwritten, or appended to, when messages are initially logged to the file.

• filename – The file which will be logged to
• overwrite – True to append to the log file, False to overwrite
• name – The name of the Logger
• prefix – The Prefix chain to use for this FileLogger
• logLevel – The log level to use for this FileLogger

The Logger class

class pyamp.logging.logger.Logger(name=None, color=0, prefix=<pyamp.logging.prefix.Prefix instance at 0xa2ddc8c>, logLevel=30, debugLevel=0, handler=<logging.StreamHandler instance at 0xa2ddd0c>)

The Logger class provides the ability to log various types of messages to a specific stream, and formats the messages using given Prefix objects.

The Logger class will log each LogLevel with a colored prefix indicating the name of the log level. Logged messages are only displayed in the event that the LogLevel at which they are logged is greater than or equal to the current LogLevel of the Logger which is logging the message. Each LogLevel.DEBUG message can also have an optional debug level specified, which will allow that message to be displayed so long as the specified debug level is less than or equal to the configured debug level of the Logger object.

Each Logger object can be named, and colored, which means that any message logged using that object will be displayed with a prefix indicating the name (and displayed in the specified color) of the object which logged the message.

Logger objects can be given a chain of Prefix objects. Any message logged using that Logger object will then have a series of prefixes added to the front of the message.

Logger objects can also have a handler specified, which specifies the type of stream which will be handled by this Logger. For example, to output to the console a value of logging.StreamHandler could be specified, whereas a value of logging.FileHandler could be specified to log to a specific file.

Example:

# Create a Logger with the name 'Example1'
logger = Logger("Example1")
logger.info("Information message")

# Create a Logger with the name 'Example2', a foreground
# color of Blue, and logs DEBUG messages that have a debug
# level less than or equal to 10.
logger = Logger("Example2", color=Colors.Foreground.Blue,
                logLevel=LogLevel.DEBUG, debugLevel=10)
logger.debug("This message is displayed", 2)
logger.debug("This message is not displayed", 11)

# Create a Logger with the name 'Example3' that only displays
# ERROR messages
logger = Logger("Example3", logLevel=LogLevel.ERROR)
logger.warn("This would not be displayed")

• name – The name of the Logger
• color – The color to use for this Logger
• prefix – The Prefix chain to use for this Logger
• logLevel – The log level to use for this Logger
• debugLevel – The debug level
• handler – The handler to use for this Logger

critical(message, *args, **kwargs)

Log a critical message.

• message – The message to log
• args – The arguments
• kwargs – The keyword arguments

debug(message, level=0, *args, **kwargs)

Log a debug message.

• message – The message to log
• level – The debug level
• args – The arguments
• kwargs – The keyword arguments

error(message, *args, **kwargs)

Log an error message.

• message – The message to log
• args – The arguments
• kwargs – The keyword arguments

fatal(message, *args, **kwargs)

Log a fatal message.

• message – The message to log
• args – The arguments
• kwargs – The keyword arguments

info(message, *args, **kwargs)

Log an info message.

• message – The message to log
• args – The arguments
• kwargs – The keyword arguments

log(logLevel, message, *args, **kwargs)

Log a message at the given log level.

• logLevel – The level at which to log
• message – The message to log
• args – The arguments
• kwargs – The keyword arguments

setName(name)

Set the name for this logger.

• name – The name

setPrefix(prefix)

Set the prefix for this logger.

• prefix – The prefix

warn(message, *args, **kwargs)

Log a warning message.

• message – The message to log
• args – The arguments
• kwargs – The keyword arguments

warning(message, *args, **kwargs)

Log a warning message.

• message – The message to log
• args – The arguments
• kwargs – The keyword arguments