System.Logger.Types

LogLevel

data LogLevel

Constructors

Quiet

Error

Warn

Info

Debug

Instances

Bounded LogLevel

Methods

minBound :: LogLevel

maxBound :: LogLevel

Enum LogLevel

Methods

succ :: LogLevel -> LogLevel

pred :: LogLevel -> LogLevel

toEnum :: Int -> LogLevel

fromEnum :: LogLevel -> Int

enumFrom :: LogLevel -> [LogLevel]

enumFromThen :: LogLevel -> LogLevel -> [LogLevel]

enumFromTo :: LogLevel -> LogLevel -> [LogLevel]

enumFromThenTo :: LogLevel -> LogLevel -> LogLevel -> [LogLevel]

Eq LogLevel

Methods

(==) :: LogLevel -> LogLevel -> Bool

(/=) :: LogLevel -> LogLevel -> Bool

Ord LogLevel

Methods

compare :: LogLevel -> LogLevel -> Ordering

(<) :: LogLevel -> LogLevel -> Bool

(<=) :: LogLevel -> LogLevel -> Bool

(>) :: LogLevel -> LogLevel -> Bool

(>=) :: LogLevel -> LogLevel -> Bool

max :: LogLevel -> LogLevel -> LogLevel

min :: LogLevel -> LogLevel -> LogLevel

Read LogLevel

Methods

readsPrec :: Int -> ReadS LogLevel

readList :: ReadS [LogLevel]

readPrec :: ReadPrec LogLevel

readListPrec :: ReadPrec [LogLevel]

Show LogLevel

Methods

showsPrec :: Int -> LogLevel -> ShowS

show :: LogLevel -> String

showList :: [LogLevel] -> ShowS

Generic LogLevel

Associated Types

type Rep LogLevel :: * -> *

Methods

from :: LogLevel -> Rep LogLevel x

to :: Rep LogLevel x -> LogLevel

ToJSON LogLevel

Methods

toJSON :: LogLevel -> Value

toEncoding :: LogLevel -> Encoding

toJSONList :: [LogLevel] -> Value

toEncodingList :: [LogLevel] -> Encoding

FromJSON LogLevel

Methods

parseJSON :: Value -> Parser LogLevel

parseJSONList :: Value -> Parser [LogLevel]

NFData LogLevel

Methods

rnf :: LogLevel -> ()

type Rep LogLevel

type Rep LogLevel = D1 (MetaData "LogLevel" "System.Logger.Types" "yet-another-logger-0.3.0-5rm0jRQNZUUFOUSMQAcGn3" False) ((:+:) ((:+:) (C1 (MetaCons "Quiet" PrefixI False) U1) (C1 (MetaCons "Error" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Warn" PrefixI False) U1) ((:+:) (C1 (MetaCons "Info" PrefixI False) U1) (C1 (MetaCons "Debug" PrefixI False) U1))))

logLevelText :: IsString a => LogLevel -> a

readLogLevel :: (MonadError e m, Eq a, Show a, FoldCase a, IsString a, IsString e, Monoid e) => a -> m LogLevel

pLogLevel :: Parser LogLevel

pLogLevel_

Arguments

:: Text

prefix for the command line options.

-> Parser LogLevel

A version of pLogLevel that takes a prefix for the command line option.

Since: 0.2

LogPolicy

data LogPolicy

Policy that determines how the case of a congested logging pipeline is addressed.

Constructors

LogPolicyDiscard

LogPolicyRaise

LogPolicyBlock

Instances

Bounded LogPolicy

Methods

minBound :: LogPolicy

maxBound :: LogPolicy

Enum LogPolicy

Methods

succ :: LogPolicy -> LogPolicy

pred :: LogPolicy -> LogPolicy

toEnum :: Int -> LogPolicy

fromEnum :: LogPolicy -> Int

enumFrom :: LogPolicy -> [LogPolicy]

enumFromThen :: LogPolicy -> LogPolicy -> [LogPolicy]

enumFromTo :: LogPolicy -> LogPolicy -> [LogPolicy]

enumFromThenTo :: LogPolicy -> LogPolicy -> LogPolicy -> [LogPolicy]

Eq LogPolicy

Methods

(==) :: LogPolicy -> LogPolicy -> Bool

(/=) :: LogPolicy -> LogPolicy -> Bool

Ord LogPolicy

Methods

compare :: LogPolicy -> LogPolicy -> Ordering

(<) :: LogPolicy -> LogPolicy -> Bool

(<=) :: LogPolicy -> LogPolicy -> Bool

(>) :: LogPolicy -> LogPolicy -> Bool

(>=) :: LogPolicy -> LogPolicy -> Bool

max :: LogPolicy -> LogPolicy -> LogPolicy

min :: LogPolicy -> LogPolicy -> LogPolicy

Read LogPolicy

Methods

readsPrec :: Int -> ReadS LogPolicy

readList :: ReadS [LogPolicy]

readPrec :: ReadPrec LogPolicy

readListPrec :: ReadPrec [LogPolicy]

Show LogPolicy

Methods

showsPrec :: Int -> LogPolicy -> ShowS

show :: LogPolicy -> String

showList :: [LogPolicy] -> ShowS

Generic LogPolicy

Associated Types

type Rep LogPolicy :: * -> *

Methods

from :: LogPolicy -> Rep LogPolicy x

to :: Rep LogPolicy x -> LogPolicy

ToJSON LogPolicy

Methods

toJSON :: LogPolicy -> Value

toEncoding :: LogPolicy -> Encoding

toJSONList :: [LogPolicy] -> Value

toEncodingList :: [LogPolicy] -> Encoding

FromJSON LogPolicy

Methods

parseJSON :: Value -> Parser LogPolicy

parseJSONList :: Value -> Parser [LogPolicy]

NFData LogPolicy

Methods

rnf :: LogPolicy -> ()

type Rep LogPolicy

type Rep LogPolicy = D1 (MetaData "LogPolicy" "System.Logger.Types" "yet-another-logger-0.3.0-5rm0jRQNZUUFOUSMQAcGn3" False) ((:+:) (C1 (MetaCons "LogPolicyDiscard" PrefixI False) U1) ((:+:) (C1 (MetaCons "LogPolicyRaise" PrefixI False) U1) (C1 (MetaCons "LogPolicyBlock" PrefixI False) U1)))

logPolicyText :: IsString s => LogPolicy -> s

readLogPolicy :: (MonadError e m, Eq a, Show a, FoldCase a, IsText a, IsString e, Monoid e) => a -> m LogPolicy

pLogPolicy :: Parser LogPolicy

pLogPolicy_

Arguments

:: Text

prefix for the command line options.

-> Parser LogPolicy

A version of pLogPolicy that takes a prefix for the command line option.

Since: 0.2

LogLabel

type LogLabel = (Text, Text)

type LogScope = [LogLabel]

Logger Exception

data LoggerException a where

Exceptions that are thrown by the logger

QueueFullException

thrown when the queue is full and the logger policy is set to throw exceptions on a full queue

BackendTerminatedException

a backend can throw this exception to force the logger immediately

BackendTooManyExceptions

thrown when the backend has thrown unexpected exceptions more than loggerConfigExceptionLimit times

Since: 0.2

Constructors

QueueFullException :: LogMessage a -> LoggerException a

BackendTerminatedException :: SomeException -> LoggerException Void

BackendTooManyExceptions :: [SomeException] -> LoggerException Void

Instances

Show a => Show (LoggerException a)

Methods

showsPrec :: Int -> LoggerException a -> ShowS

show :: LoggerException a -> String

showList :: [LoggerException a] -> ShowS

(Typeable * a, Show a) => Exception (LoggerException a)

Methods

toException :: LoggerException a -> SomeException

fromException :: SomeException -> Maybe (LoggerException a)

displayException :: LoggerException a -> String

Logger Backend

data LogMessage a

The Internal log message type.

The type parameter a is expected to provide intances of Show, Typeable, and NFData.

If we need to support different backends, we may consider including the backend here...

Constructors

LogMessage

Fields

• _logMsg :: !a
• _logMsgLevel :: !LogLevel
• _logMsgScope :: !LogScope

  efficiency of this depends on whether this is shared between log messsages. Usually this should be just a pointer to a shared list.

• _logMsgTime :: !TimeSpec

  a POSIX timestamp

  UTC seconds elapsed since UNIX Epoch as returned by clock_gettime on the respective system. NOTE that POSIX is ambigious with regard to treatment of leap seconds, and some implementations may actually return TAI.

  Since: 0.2

Instances

Eq a => Eq (LogMessage a)

Methods

(==) :: LogMessage a -> LogMessage a -> Bool

(/=) :: LogMessage a -> LogMessage a -> Bool

Ord a => Ord (LogMessage a)

Methods

compare :: LogMessage a -> LogMessage a -> Ordering

(<) :: LogMessage a -> LogMessage a -> Bool

(<=) :: LogMessage a -> LogMessage a -> Bool

(>) :: LogMessage a -> LogMessage a -> Bool

(>=) :: LogMessage a -> LogMessage a -> Bool

max :: LogMessage a -> LogMessage a -> LogMessage a

min :: LogMessage a -> LogMessage a -> LogMessage a

Read a => Read (LogMessage a)

Methods

readsPrec :: Int -> ReadS (LogMessage a)

readList :: ReadS [LogMessage a]

readPrec :: ReadPrec (LogMessage a)

readListPrec :: ReadPrec [LogMessage a]

Show a => Show (LogMessage a)

Methods

showsPrec :: Int -> LogMessage a -> ShowS

show :: LogMessage a -> String

showList :: [LogMessage a] -> ShowS

Generic (LogMessage a)

Associated Types

type Rep (LogMessage a) :: * -> *

Methods

from :: LogMessage a -> Rep (LogMessage a) x

to :: Rep (LogMessage a) x -> LogMessage a

NFData a => NFData (LogMessage a)

Methods

rnf :: LogMessage a -> ()

type Rep (LogMessage a)

type Rep (LogMessage a) = D1 (MetaData "LogMessage" "System.Logger.Types" "yet-another-logger-0.3.0-5rm0jRQNZUUFOUSMQAcGn3" False) (C1 (MetaCons "LogMessage" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_logMsg") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Just Symbol "_logMsgLevel") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 LogLevel))) ((:*:) (S1 (MetaSel (Just Symbol "_logMsgScope") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 LogScope)) (S1 (MetaSel (Just Symbol "_logMsgTime") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 TimeSpec)))))

logMsg :: Lens (LogMessage a) (LogMessage b) a b

logMsgLevel :: Lens' (LogMessage a) LogLevel

logMsgScope :: Lens' (LogMessage a) LogScope

logMsgTime :: Lens' (LogMessage a) TimeSpec

Since: 0.2

type LoggerBackend a = Either (LogMessage Text) (LogMessage a) -> IO ()

This is given to logger when it is created. It formats and delivers individual log messages synchronously. The backend is called once for each log message (that meets the required log level).

The type parameter a is expected to provide instances for Show Typeable, and NFData.

The Left values of the argument allows the generation of log messages that are independent of the parameter a. The motivation for this is reporting issues in Logging system itself, like a full logger queue or providing statistics about the fill level of the queue. There may be other uses of this, too.

Backends that can fail are encouraged (but not forced) to take into account the LogPolicy that is effective for a message. For instance, a backend may implement a reasonable retry logic for each message and then raise a BackendTerminatedException in case the policy is LogPolicyBlock or LogPolicyRaise (thus causing the logger to exit immediately) and raise some other exception otherwise (thus discarding the message without causing the logger to not exit immediately). In addition a backend might retry harder in case of LogPolicyBlock.

TODO there may be scenarios where chunked processing is beneficial. While this can be done in a closure of this function, more direct support might be desirable.

Logger Frontend

type LogFunction a m = LogLevel -> a -> m ()

type LogFunctionIO a = LogLevel -> a -> IO ()

This function is provided by the logger.

LoggerCtx

class LoggerCtx ctx msg | ctx -> msg where

Abstraction of a logger context that can be used without dependening on a specific monadic context.

The loggerFunIO incorporates a LoggerBackend. An instance of a LoggerCtx is free to use a hard coded LoggerBackend or to be usable with different LoggerBackend functions. The latter is recommended but not required.

You don't have to provide an instance of this for your logger. Instead you may just provide an instance of MonadLog directly.

If this doesn't fit your needs you may use a newtype wrapper and define your own instances.

Minimal complete definition

loggerFunIO, setLoggerLevel, setLoggerScope, setLoggerPolicy

Methods

loggerFunIO :: (Show msg, Typeable msg, NFData msg) => ctx -> LogFunctionIO msg

setLoggerLevel :: Setter' ctx LogLevel

setLoggerScope :: Setter' ctx LogScope

setLoggerPolicy :: Setter' ctx LogPolicy

withLoggerLevel :: LogLevel -> ctx -> (ctx -> α) -> α

withLoggerLabel :: LogLabel -> ctx -> (ctx -> α) -> α

withLoggerPolicy :: LogPolicy -> ctx -> (ctx -> α) -> α

Instances

LoggerCtx (Logger a) a

Methods

loggerFunIO :: Logger a -> LogFunctionIO a

setLoggerLevel :: Setter' (Logger a) LogLevel

setLoggerScope :: Setter' (Logger a) LogScope

setLoggerPolicy :: Setter' (Logger a) LogPolicy

withLoggerLevel :: LogLevel -> Logger a -> (Logger a -> α) -> α

withLoggerLabel :: LogLabel -> Logger a -> (Logger a -> α) -> α

withLoggerPolicy :: LogPolicy -> Logger a -> (Logger a -> α) -> α

data LoggerCtxT ctx m α

Instances

MonadState a m => MonadState a (LoggerCtxT ctx m)

Methods

get :: LoggerCtxT ctx m a

put :: a -> LoggerCtxT ctx m ()

state :: (a -> (a, a)) -> LoggerCtxT ctx m a

Monad m => MonadReader ctx (LoggerCtxT ctx m)

Methods

ask :: LoggerCtxT ctx m ctx

local :: (ctx -> ctx) -> LoggerCtxT ctx m a -> LoggerCtxT ctx m a

reader :: (ctx -> a) -> LoggerCtxT ctx m a

MonadWriter a m => MonadWriter a (LoggerCtxT ctx m)

Methods

writer :: (a, a) -> LoggerCtxT ctx m a

tell :: a -> LoggerCtxT ctx m ()

listen :: LoggerCtxT ctx m a -> LoggerCtxT ctx m (a, a)

pass :: LoggerCtxT ctx m (a, a -> a) -> LoggerCtxT ctx m a

MonadError a m => MonadError a (LoggerCtxT ctx m)

Methods

throwError :: a -> LoggerCtxT ctx m a

catchError :: LoggerCtxT ctx m a -> (a -> LoggerCtxT ctx m a) -> LoggerCtxT ctx m a

MonadBase a m => MonadBase a (LoggerCtxT ctx m)

Methods

liftBase :: a α -> LoggerCtxT ctx m α

MonadBaseControl b m => MonadBaseControl b (LoggerCtxT ctx m)

Associated Types

type StM (LoggerCtxT ctx m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (LoggerCtxT ctx m) b -> b a) -> LoggerCtxT ctx m a

restoreM :: StM (LoggerCtxT ctx m) a -> LoggerCtxT ctx m a

(Show a, Typeable * a, NFData a, MonadIO m, LoggerCtx ctx a) => MonadLog a (LoggerCtxT ctx m)

Methods

logg :: LogFunction a (LoggerCtxT ctx m)

withLevel :: LogLevel -> LoggerCtxT ctx m α -> LoggerCtxT ctx m α

withPolicy :: LogPolicy -> LoggerCtxT ctx m α -> LoggerCtxT ctx m α

localScope :: (LogScope -> LogScope) -> LoggerCtxT ctx m α -> LoggerCtxT ctx m α

MonadTrans (LoggerCtxT ctx)

Methods

lift :: Monad m => m a -> LoggerCtxT ctx m a

MonadTransControl (LoggerCtxT ctx)

Associated Types

type StT (LoggerCtxT ctx :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run (LoggerCtxT ctx) -> m a) -> LoggerCtxT ctx m a

restoreT :: Monad m => m (StT (LoggerCtxT ctx) a) -> LoggerCtxT ctx m a

Monad m => Monad (LoggerCtxT ctx m)

Methods

(>>=) :: LoggerCtxT ctx m a -> (a -> LoggerCtxT ctx m b) -> LoggerCtxT ctx m b

(>>) :: LoggerCtxT ctx m a -> LoggerCtxT ctx m b -> LoggerCtxT ctx m b

return :: a -> LoggerCtxT ctx m a

fail :: String -> LoggerCtxT ctx m a

Functor m => Functor (LoggerCtxT ctx m)

Methods

fmap :: (a -> b) -> LoggerCtxT ctx m a -> LoggerCtxT ctx m b

(<$) :: a -> LoggerCtxT ctx m b -> LoggerCtxT ctx m a

Applicative m => Applicative (LoggerCtxT ctx m)

Methods

pure :: a -> LoggerCtxT ctx m a

(<*>) :: LoggerCtxT ctx m (a -> b) -> LoggerCtxT ctx m a -> LoggerCtxT ctx m b

(*>) :: LoggerCtxT ctx m a -> LoggerCtxT ctx m b -> LoggerCtxT ctx m b

(<*) :: LoggerCtxT ctx m a -> LoggerCtxT ctx m b -> LoggerCtxT ctx m a

MonadIO m => MonadIO (LoggerCtxT ctx m)

Methods

liftIO :: IO a -> LoggerCtxT ctx m a

MonadThrow m => MonadThrow (LoggerCtxT ctx m)

Methods

throwM :: Exception e => e -> LoggerCtxT ctx m a

MonadCatch m => MonadCatch (LoggerCtxT ctx m)

Methods

catch :: Exception e => LoggerCtxT ctx m a -> (e -> LoggerCtxT ctx m a) -> LoggerCtxT ctx m a

MonadMask m => MonadMask (LoggerCtxT ctx m)

Methods

mask :: ((forall a. LoggerCtxT ctx m a -> LoggerCtxT ctx m a) -> LoggerCtxT ctx m b) -> LoggerCtxT ctx m b

uninterruptibleMask :: ((forall a. LoggerCtxT ctx m a -> LoggerCtxT ctx m a) -> LoggerCtxT ctx m b) -> LoggerCtxT ctx m b

type StT (LoggerCtxT ctx) a

type StT (LoggerCtxT ctx) a = StT (ReaderT * ctx) a

type StM (LoggerCtxT ctx m) a

type StM (LoggerCtxT ctx m) a = ComposeSt (LoggerCtxT ctx) m a

runLoggerCtxT :: LoggerCtxT ctx m α -> ctx -> m α

MonadLog

class Monad m => MonadLog a m | m -> a where

Minimal complete definition

logg, withLevel, withPolicy, localScope

Methods

logg :: LogFunction a m

Log a message.

withLevel :: LogLevel -> m α -> m α

Run the inner computation with the given LogLevel

withPolicy :: LogPolicy -> m α -> m α

Run the inner computation with the given LogPolicy.

localScope :: (LogScope -> LogScope) -> m α -> m α

Run the inner computation with a modified LogScope.

Since: 0.1

Instances

(Show a, Typeable * a, NFData a, MonadIO m, LoggerCtx ctx a) => MonadLog a (LoggerCtxT ctx m)

Methods

logg :: LogFunction a (LoggerCtxT ctx m)

withLevel :: LogLevel -> LoggerCtxT ctx m α -> LoggerCtxT ctx m α

withPolicy :: LogPolicy -> LoggerCtxT ctx m α -> LoggerCtxT ctx m α

localScope :: (LogScope -> LogScope) -> LoggerCtxT ctx m α -> LoggerCtxT ctx m α

MonadLog a m => MonadLog a (StateT σ m)

Methods

logg :: LogFunction a (StateT σ m)

withLevel :: LogLevel -> StateT σ m α -> StateT σ m α

withPolicy :: LogPolicy -> StateT σ m α -> StateT σ m α

localScope :: (LogScope -> LogScope) -> StateT σ m α -> StateT σ m α

MonadLog a m => MonadLog a (ExceptT ε m)

Methods

logg :: LogFunction a (ExceptT ε m)

withLevel :: LogLevel -> ExceptT ε m α -> ExceptT ε m α

withPolicy :: LogPolicy -> ExceptT ε m α -> ExceptT ε m α

localScope :: (LogScope -> LogScope) -> ExceptT ε m α -> ExceptT ε m α

(Monoid σ, MonadLog a m) => MonadLog a (WriterT σ m)

Methods

logg :: LogFunction a (WriterT σ m)

withLevel :: LogLevel -> WriterT σ m α -> WriterT σ m α

withPolicy :: LogPolicy -> WriterT σ m α -> WriterT σ m α

localScope :: (LogScope -> LogScope) -> WriterT σ m α -> WriterT σ m α

withLabel :: MonadLog a m => LogLabel -> m α -> m α

Append a LogLabel to the current LogScope when executing the inner computation. The LogScope of the outer computation is unchanged.

Since: 0.1

clearScope :: MonadLog a m => m α -> m α

Executing the inner computation with an empty LogScope. The LogScope of the outer computation is unchanged.

Since: 0.1

popLabel :: MonadLog a m => m α -> m α

Remove the last LogLabel from the current LogScope when executing the inner computation. The LogScope of the outer computation is unchanged.

Since: 0.1

Orphan instances

NFData TimeSpec

Methods

rnf :: TimeSpec -> ()