Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- type Logger = String
- newtype Level = Level Int
- newtype Filter = Filter Logger
- type Filterer = [Filter]
- data LogRecord = LogRecord {}
- data StreamHandler = StreamHandler {}
- data FileHandler = FileHandler {}
- data RotatingFileHandler = RotatingFileHandler {}
- data Sink = Sink {}
- data Manager = Manager {}
- class Filterable a where
- data SomeHandler where
- SomeHandler :: Handler h => h -> SomeHandler
- class (HasType Level a, HasType Filterer a, HasType Format1 a, Typeable a, Eq a) => Handler a where
Documentation
Level
also known as severity, a higher Level
means a bigger Int
.
There are 5 common severity levels:
DEBUG
- Level 10
INFO
- Level 20
WARN
- Level 30
ERROR
- Level 40
FATAL
- Level 50
>>>
:set -XOverloadedStrings
>>>
"DEBUG" :: Level
DEBUG>>>
"DEBUG" == (Level 10)
True
Instances
Enum Level Source # | |
Eq Level Source # | |
Ord Level Source # | |
Read Level Source # | |
Show Level Source # | |
IsString Level Source # | |
Defined in Logging.Types.Level fromString :: String -> Level # | |
FromJSON Level Source # | |
Default Level Source # | |
Defined in Logging.Types.Level | |
FormatArg Level Source # | |
HasType Level SomeHandler Source # | |
Defined in Logging.Types.Class.Handler typed :: Lens SomeHandler SomeHandler Level Level # getTyped :: SomeHandler -> Level # setTyped :: Level -> SomeHandler -> SomeHandler # |
Filter
s are used to perform arbitrary filtering of LogRecord
s.
Sink
s and Handler
s can optionally use Filter
to filter records
as desired. It allows events which are below a certain point in the
sink hierarchy. For example, a filter initialized with A.B will allow
events logged by loggers A.B, A.B.C, A.B.C.D, A.B.D etc.
but not A.BB, B.A.B etc.
If initialized name with the empty string, all events are passed.
Instances
Eq Filter Source # | |
Read Filter Source # | |
Show Filter Source # | |
IsString Filter Source # | |
Defined in Logging.Types.Filter fromString :: String -> Filter # | |
FromJSON Filter Source # | |
Filterable Filter Source # | |
HasType Filterer SomeHandler Source # | |
Defined in Logging.Types.Class.Handler typed :: Lens SomeHandler SomeHandler Filterer Filterer # getTyped :: SomeHandler -> Filterer # setTyped :: Filterer -> SomeHandler -> SomeHandler # |
A LogRecord
represents an event being logged.
LogRecord
s are created every time something is logged. They
contain all the information related to the event being logged.
It includes the main message as well as information such as when the record was created, the source line where the logging call was made.
LogRecord
can be formatted into string by Format
from vformat
package, see format1
for more information.
Currently, the useful attributes in a LogRecord are described by:
logger name of the logger, seeLogger
level logging level for the message, seeLevel
message the main message passed to logv debug info .. pathname full pathname of the source file where the logging call was issued (if available) filename filename portion of pathname pkgname package name where the logging call was issued (if available) modulename module name (e.g. Main, Logging.Types) lineno source line number where the logging call was issued (if available) asctimeZonedTime
when the LogRecord was created utctimeUTCTime
when the LogRecord was created created timestamp when the LogRecord was created msecs millisecond portion of the creation time
Format examples:
"{message}" "{logger} {level}: {message}" "{logger:<20.20s} {level:<8s}: {message}" "{asctime:%Y-%m-%dT%H:%M:%S%6Q%z} - {level} - {logger}] {message}"
Instances
data StreamHandler Source #
A handler type which writes logging records, appropriately formatted, to a stream.
Instances
data FileHandler Source #
A handler type which writes logging records, appropriately formatted, to a file.
Instances
data RotatingFileHandler Source #
A handler type which writes logging records, appropriately formatted, to a file, it will rotate when file is too large.
UNTESTED
Since 0.3.0
Instances
Sink
represents a single logging channel.
A "logging channel" indicates an area of an application. Exactly how an "area" is defined is up to the application developer. Since an application can have any number of areas, logging channels are identified by a unique string. Application areas can be nested (e.g. an area of "input processing" might include sub-areas "read CSV files", "read XLS files" and "read Gnumeric files"). To cater for this natural nesting, channel names are organized into a namespace hierarchy where levels are separated by periods, much like the Haskell module namespace. So in the instance given above, channel names might be Input for the upper level, and Input.Csv, Input.Xls and Input.Gnu for the sub-levels. There is no arbitrary limit to the depth of nesting.
Note: The namespaces are case sensitive.
There is under normal circumstances just one Manager, which holds the hierarchy of sinks.
class Filterable a where Source #
A class represents a common trait of filtering LogRecord
s
Instances
Filterable Filter Source # | |
Filterable Sink Source # | |
Filterable a => Filterable [a] Source # | |
data SomeHandler where Source #
The SomeHandler
type is the root of the handler type hierarchy.
It holds the real Handler
instance
SomeHandler :: Handler h => h -> SomeHandler |
Instances
class (HasType Level a, HasType Filterer a, HasType Format1 a, Typeable a, Eq a) => Handler a where Source #
A type class that abstracts the characteristics of a Handler
Note: Locking is not necessary, because Handle
has done it on
handle operations.
emit :: a -> LogRecord -> IO () Source #
handle :: a -> LogRecord -> IO Bool Source #
fromHandler :: SomeHandler -> Maybe a Source #
toHandler :: a -> SomeHandler Source #