Control.Eff.Log.Writer

The LogWriter type encapsulates an effectful function to write LogMessages.

Used in conjunction with the HandleLogWriter class, it can be used to write messages from within an effectful computation.

LogWriter Definition

newtype LogWriter writerM

A function that takes a log message and returns an effect that logs the message.

Constructors

MkLogWriter

Fields

• runLogWriter :: LogMessage -> writerM ()

Instances

Applicative w => Default (LogWriter w)

Defined in Control.Eff.Log.Writer

Methods

def :: LogWriter w

Handle (LogWriterReader h) e a (LogWriter h -> k)

Defined in Control.Eff.Log.Writer

Methods

handle :: (Eff e a -> LogWriter h -> k) -> Arrs e v a -> LogWriterReader h v -> LogWriter h -> k

handle_relay :: (e ~ (LogWriterReader h ': r'), Relay (LogWriter h -> k) r') => (a -> LogWriter h -> k) -> (Eff e a -> LogWriter h -> k) -> Eff e a -> LogWriter h -> k

respond_relay :: (a -> LogWriter h -> k) -> (Eff e a -> LogWriter h -> k) -> Eff e a -> LogWriter h -> k

LogWriter Reader Effect

data LogWriterReader h v

A Reader specialized for LogWriters

The existing Reader couldn't be used together with SetMember, so this lazy reader was written, specialized to reading LogWriter.

Instances

(MonadBase m m, LiftedBase m r) => MonadBaseControl m (Eff (LogWriterReader h ': r))

Defined in Control.Eff.Log.Writer

Associated Types

type StM (Eff (LogWriterReader h ': r)) a :: Type

Methods

liftBaseWith :: (RunInBase (Eff (LogWriterReader h ': r)) m -> m a) -> Eff (LogWriterReader h ': r) a

restoreM :: StM (Eff (LogWriterReader h ': r)) a -> Eff (LogWriterReader h ': r) a

(LiftedBase m e, MonadThrow (Eff e)) => MonadThrow (Eff (LogWriterReader h ': e))

Defined in Control.Eff.Log.Writer

Methods

throwM :: Exception e0 => e0 -> Eff (LogWriterReader h ': e) a

(Applicative m, LiftedBase m e, MonadCatch (Eff e)) => MonadCatch (Eff (LogWriterReader h ': e))

Defined in Control.Eff.Log.Writer

Methods

catch :: Exception e0 => Eff (LogWriterReader h ': e) a -> (e0 -> Eff (LogWriterReader h ': e) a) -> Eff (LogWriterReader h ': e) a

(Applicative m, LiftedBase m e, MonadMask (Eff e)) => MonadMask (Eff (LogWriterReader h ': e))

Defined in Control.Eff.Log.Writer

Methods

mask :: ((forall a. Eff (LogWriterReader h ': e) a -> Eff (LogWriterReader h ': e) a) -> Eff (LogWriterReader h ': e) b) -> Eff (LogWriterReader h ': e) b

uninterruptibleMask :: ((forall a. Eff (LogWriterReader h ': e) a -> Eff (LogWriterReader h ': e) a) -> Eff (LogWriterReader h ': e) b) -> Eff (LogWriterReader h ': e) b

generalBracket :: Eff (LogWriterReader h ': e) a -> (a -> ExitCase b -> Eff (LogWriterReader h ': e) c) -> (a -> Eff (LogWriterReader h ': e) b) -> Eff (LogWriterReader h ': e) (b, c)

Handle (LogWriterReader h) e a (LogWriter h -> k)

Defined in Control.Eff.Log.Writer

Methods

handle :: (Eff e a -> LogWriter h -> k) -> Arrs e v a -> LogWriterReader h v -> LogWriter h -> k

handle_relay :: (e ~ (LogWriterReader h ': r'), Relay (LogWriter h -> k) r') => (a -> LogWriter h -> k) -> (Eff e a -> LogWriter h -> k) -> Eff e a -> LogWriter h -> k

respond_relay :: (a -> LogWriter h -> k) -> (Eff e a -> LogWriter h -> k) -> Eff e a -> LogWriter h -> k

type StM (Eff (LogWriterReader h ': r)) a

Defined in Control.Eff.Log.Writer

type StM (Eff (LogWriterReader h ': r)) a = StM (Eff r) a

localLogWriterReader :: forall h e a. SetMember LogWriterReader (LogWriterReader h) e => (LogWriter h -> LogWriter h) -> Eff e a -> Eff e a

Modify the current LogWriter.

askLogWriter :: SetMember LogWriterReader (LogWriterReader h) e => Eff e (LogWriter h)

Get the current LogWriter.

runLogWriterReader :: LogWriter h -> Eff (LogWriterReader h ': e) a -> Eff e a

Provide the LogWriter

Exposed for custom extensions, if in doubt use withLogging.

LogWriter Handler Class

class HandleLogWriter (writerEff :: Type -> Type) where

The instances of this class are the monads that define (side-) effect(s) of writting logs.

Minimal complete definition

handleLogWriterEffect

Associated Types

type LogWriterEffects writerEff :: [Type -> Type]

A list of effects that are required for writing the log messages. For example 'Lift IO' or '[]' for pure log writers.

Methods

handleLogWriterEffect :: LogWriterEffects writerEff <:: e => writerEff () -> Eff e ()

Run the side effect of a LogWriter in a compatible Eff.

liftWriteLogMessage :: (SetMember LogWriterReader (LogWriterReader writerEff) e, LogWriterEffects writerEff <:: e) => LogMessage -> Eff e ()

Write a message using the LogWriter found in the environment.

The semantics of this function are a combination of runLogWriter and handleLogWriterEffect, with the LogWriter read from a LogWriterReader.

Instances

HandleLogWriter IO

Defined in Control.Eff.Log.Writer

Associated Types

type LogWriterEffects IO :: [Type -> Type]

Methods

handleLogWriterEffect :: LogWriterEffects IO <:: e => IO () -> Eff e ()

liftWriteLogMessage :: (SetMember LogWriterReader (LogWriterReader IO) e, LogWriterEffects IO <:: e) => LogMessage -> Eff e ()

HandleLogWriter CaptureLogs

A LogWriter monad for pure logging.

The HandleLogWriter instance for this type assumes a Writer effect.

Defined in Control.Eff.Log.Writer

Associated Types

type LogWriterEffects CaptureLogs :: [Type -> Type]

Methods

handleLogWriterEffect :: LogWriterEffects CaptureLogs <:: e => CaptureLogs () -> Eff e ()

liftWriteLogMessage :: (SetMember LogWriterReader (LogWriterReader CaptureLogs) e, LogWriterEffects CaptureLogs <:: e) => LogMessage -> Eff e ()

HandleLogWriter PureLogWriter

A LogWriter monad for Trace based pure logging.

Defined in Control.Eff.Log.Writer

Associated Types

type LogWriterEffects PureLogWriter :: [Type -> Type]

Methods

handleLogWriterEffect :: LogWriterEffects PureLogWriter <:: e => PureLogWriter () -> Eff e ()

liftWriteLogMessage :: (SetMember LogWriterReader (LogWriterReader PureLogWriter) e, LogWriterEffects PureLogWriter <:: e) => LogMessage -> Eff e ()

LogWriter Handler Instance Zoo

Pure Writer

noOpLogWriter :: Applicative m => LogWriter m

This LogWriter will discard all messages.

NOTE: This is just an alias for def

debugTraceLogWriter :: Monad h => LogWriter h

A LogWriter that applies renderLogMessage to the log message and then traces it using traceM. This LogWriter work with any base monad.

newtype PureLogWriter a

A phantom type for the HandleLogWriter class for pure LogWriters

Constructors

MkPureLogWriter

Fields

• runPureLogWriter :: Identity a

Instances

Monad PureLogWriter

Defined in Control.Eff.Log.Writer

Methods

(>>=) :: PureLogWriter a -> (a -> PureLogWriter b) -> PureLogWriter b

(>>) :: PureLogWriter a -> PureLogWriter b -> PureLogWriter b

return :: a -> PureLogWriter a

fail :: String -> PureLogWriter a

Functor PureLogWriter

Defined in Control.Eff.Log.Writer

Methods

fmap :: (a -> b) -> PureLogWriter a -> PureLogWriter b

(<$) :: a -> PureLogWriter b -> PureLogWriter a

Applicative PureLogWriter

Defined in Control.Eff.Log.Writer

Methods

pure :: a -> PureLogWriter a

(<*>) :: PureLogWriter (a -> b) -> PureLogWriter a -> PureLogWriter b

liftA2 :: (a -> b -> c) -> PureLogWriter a -> PureLogWriter b -> PureLogWriter c

(*>) :: PureLogWriter a -> PureLogWriter b -> PureLogWriter b

(<*) :: PureLogWriter a -> PureLogWriter b -> PureLogWriter a

HandleLogWriter PureLogWriter

A LogWriter monad for Trace based pure logging.

Defined in Control.Eff.Log.Writer

Associated Types

type LogWriterEffects PureLogWriter :: [Type -> Type]

Methods

handleLogWriterEffect :: LogWriterEffects PureLogWriter <:: e => PureLogWriter () -> Eff e ()

liftWriteLogMessage :: (SetMember LogWriterReader (LogWriterReader PureLogWriter) e, LogWriterEffects PureLogWriter <:: e) => LogMessage -> Eff e ()

type LogWriterEffects PureLogWriter

Defined in Control.Eff.Log.Writer

type LogWriterEffects PureLogWriter = ([] :: [Type -> Type])

List Writer

listLogWriter :: LogWriter CaptureLogs

A LogWriter monad that provides pure logging by capturing via the Writer effect.

newtype CaptureLogs a

A LogWriter monad that provides pure logging by capturing via the Writer effect.

Constructors

MkCaptureLogs

Fields

• unCaptureLogs :: Eff '[CapturedLogsWriter] a

Instances

Monad CaptureLogs

Defined in Control.Eff.Log.Writer

Methods

(>>=) :: CaptureLogs a -> (a -> CaptureLogs b) -> CaptureLogs b

(>>) :: CaptureLogs a -> CaptureLogs b -> CaptureLogs b

return :: a -> CaptureLogs a

fail :: String -> CaptureLogs a

Functor CaptureLogs

Defined in Control.Eff.Log.Writer

Methods

fmap :: (a -> b) -> CaptureLogs a -> CaptureLogs b

(<$) :: a -> CaptureLogs b -> CaptureLogs a

Applicative CaptureLogs

Defined in Control.Eff.Log.Writer

Methods

pure :: a -> CaptureLogs a

(<*>) :: CaptureLogs (a -> b) -> CaptureLogs a -> CaptureLogs b

liftA2 :: (a -> b -> c) -> CaptureLogs a -> CaptureLogs b -> CaptureLogs c

(*>) :: CaptureLogs a -> CaptureLogs b -> CaptureLogs b

(<*) :: CaptureLogs a -> CaptureLogs b -> CaptureLogs a

HandleLogWriter CaptureLogs

A LogWriter monad for pure logging.

The HandleLogWriter instance for this type assumes a Writer effect.

Defined in Control.Eff.Log.Writer

Associated Types

type LogWriterEffects CaptureLogs :: [Type -> Type]

Methods

handleLogWriterEffect :: LogWriterEffects CaptureLogs <:: e => CaptureLogs () -> Eff e ()

liftWriteLogMessage :: (SetMember LogWriterReader (LogWriterReader CaptureLogs) e, LogWriterEffects CaptureLogs <:: e) => LogMessage -> Eff e ()

type LogWriterEffects CaptureLogs

Defined in Control.Eff.Log.Writer

type LogWriterEffects CaptureLogs = CapturedLogsWriter ': ([] :: [Type -> Type])

type CapturedLogsWriter = Writer LogMessage

Alias for the Writer that contains the captured LogMessages from CaptureLogs.

runCapturedLogsWriter :: Eff (CapturedLogsWriter ': e) a -> Eff e (a, [LogMessage])

Run a Writer for LogMessages.

Such a Writer is needed for CaptureLogs

IO Writer

consoleLogWriter :: LogWriter IO

Write LogMessages to standard output, formatted with printLogMessage.

ioHandleLogWriter :: HasCallStack => Handle -> LogWriter IO

A LogWriter that renders LogMessages to strings via renderLogMessage and prints them to an Handle using hPutStrLn.

Writer Combinator

Pure Writer Combinator

filteringLogWriter :: Monad e => LogPredicate -> LogWriter e -> LogWriter e

A LogWriter that applies a predicate to the LogMessage and delegates to to the given writer of the predicate is satisfied.

mappingLogWriter :: (LogMessage -> LogMessage) -> LogWriter e -> LogWriter e

A LogWriter that applies a function to the LogMessage and delegates the result to to the given writer.

Impure Writer Combinator

mappingLogWriterM :: Monad e => (LogMessage -> e LogMessage) -> LogWriter e -> LogWriter e

Like mappingLogWriter allow the function that changes the LogMessage to have effects.

IO Based Combinator

ioLogWriter :: HasCallStack => (LogMessage -> IO ()) -> LogWriter IO

A LogWriter that uses an IO action to write the message.

Example use cases for this function are the consoleLogWriter and the ioHandleLogWriter.

defaultIoLogWriter

Arguments

:: String

The default application name to put into the lmAppName field.

-> Facility

The default RFC-5424 facility to put into the lmFacility field.

-> LogWriter IO

The IO based writer to decorate

-> LogWriter IO

Decorate an IO based LogWriter to fill out these fields in LogMessages:

• The messages will carry the given application name in the lmAppName field.
• The lmTimestamp field contains the UTC time of the log event
• The lmThreadId field contains the thread-Id
• The lmHostname field contains the FQDN of the current host
• The lmFacility field contains the given Facility

It works by using mappingLogWriterM.