Control.Eff.Log.Handler

A logging effect based on MonadLog.

Documentation

logMsg :: (NFData m, Member (Logs m) e) => m -> Eff e ()

Log a message. The message is reduced to normal form (strict).

logMsgs :: (Traversable f, MonadPlus f, NFData1 f, NFData (f m), NFData m, Member (Logs m) e) => f m -> Eff e ()

Log a bunch of messages. This might be more efficient than calling logMsg multiple times. The messages are reduced to normal form (strict).

type HasLogWriter message logWriterMonad effects = (Member (Reader (LogWriter message logWriterMonad)) effects, Member (Logs message) effects, NFData message, Monad logWriterMonad, Lifted logWriterMonad effects)

A constraint that combines constraints for logging into any log writer monad.

mapLogMessages :: forall m r b. (NFData m, Member (Logs m) r) => (m -> m) -> Eff r b -> Eff r b

Map a pure function over log messages.

filterLogMessages :: forall m r b. (NFData m, Member (Logs m) r) => (m -> Bool) -> Eff r b -> Eff r b

Keep only those messages, for which a predicate holds.

E.g. to keep only messages which begin with OMG:

filterLogMessages (\msg -> case msg of
                            'O':'M':'G':_ -> True
                             _            -> False)
                  (do logMsg "this message will not be logged"
                      logMsg "OMG logged")

traverseLogMessages :: forall m r h b. (Member (Logs m) r, Monad h, Lifted h r, Member (Reader (LogWriter m h)) r) => (forall f. (MonadPlus f, Traversable f, NFData1 f) => f m -> h (f m)) -> Eff r b -> Eff r b

Map an Effectful function over every bunch of log messages.

For example, to attach the current time to each log message:

appendTimestamp
 :: ( Member (Logs String) e
    , Lifted IO e)
 => Eff e a
 -> Eff e a
appendTimestamp = traverseLogMessages $ \ms -> do
  now <- getCurrentTime
  return (fmap (show now ++) ms)

changeLogWriter :: forall r m h a. (Monad h, Lifted h r, Member (Reader (LogWriter m h)) r) => (forall f. (Traversable f, NFData1 f, MonadPlus f) => f m -> Eff '[Reader (LogWriter m h), Lift h] ()) -> Eff r a -> Eff r a

Change the way log messages are *written*. Replaces the existing LogWriter by a new one. The new LogWriter is constructed from a function that gets a bunch of messages and returns an Effect. That effect has a Reader for the previous LogWriter and Lifts the log writer base monad.

ignoreLogs :: forall message r a. Eff (Logs message ': r) a -> Eff r a

Throw away all log messages.

traceLogs :: forall message r a. (message -> String) -> Eff (Logs message ': r) a -> Eff r a

Trace all log messages using traceM. The message value is converted to String using the given function.

data LogWriter message writerM

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

Instances

(MonadBase m m, Lifted m r, NFData l, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Logs l ': (LogWriterReader l m ': r)))

This instance allows liftings of the Logs effect, but only, if there is a LogWriter in effect.

Defined in Control.Eff.Log.Handler

Associated Types

type StM (Eff (Logs l ': (LogWriterReader l m ': r))) a :: Type

Methods

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

restoreM :: StM (Eff (Logs l ': (LogWriterReader l m ': r))) a -> Eff (Logs l ': (LogWriterReader l m ': r)) a

(NFData l, Lifted m e, MonadThrow (Eff e)) => MonadThrow (Eff (Logs l ': (LogWriterReader l m ': e)))

Defined in Control.Eff.Log.Handler

Methods

throwM :: Exception e0 => e0 -> Eff (Logs l ': (LogWriterReader l m ': e)) a

(NFData l, Applicative m, Lifted m e, MonadCatch (Eff e)) => MonadCatch (Eff (Logs l ': (LogWriterReader l m ': e)))

Defined in Control.Eff.Log.Handler

Methods

catch :: Exception e0 => Eff (Logs l ': (LogWriterReader l m ': e)) a -> (e0 -> Eff (Logs l ': (LogWriterReader l m ': e)) a) -> Eff (Logs l ': (LogWriterReader l m ': e)) a

(NFData l, Applicative m, Lifted m e, MonadMask (Eff e)) => MonadMask (Eff (Logs l ': (LogWriterReader l m ': e)))

Defined in Control.Eff.Log.Handler

Methods

mask :: ((forall a. Eff (Logs l ': (LogWriterReader l m ': e)) a -> Eff (Logs l ': (LogWriterReader l m ': e)) a) -> Eff (Logs l ': (LogWriterReader l m ': e)) b) -> Eff (Logs l ': (LogWriterReader l m ': e)) b

uninterruptibleMask :: ((forall a. Eff (Logs l ': (LogWriterReader l m ': e)) a -> Eff (Logs l ': (LogWriterReader l m ': e)) a) -> Eff (Logs l ': (LogWriterReader l m ': e)) b) -> Eff (Logs l ': (LogWriterReader l m ': e)) b

generalBracket :: Eff (Logs l ': (LogWriterReader l m ': e)) a -> (a -> ExitCase b -> Eff (Logs l ': (LogWriterReader l m ': e)) c) -> (a -> Eff (Logs l ': (LogWriterReader l m ': e)) b) -> Eff (Logs l ': (LogWriterReader l m ': e)) (b, c)

Applicative w => Default (LogWriter m w)

Defined in Control.Eff.Log.Handler

Methods

def :: LogWriter m w

type StM (Eff (Logs l ': (LogWriterReader l m ': r))) a

Defined in Control.Eff.Log.Handler

type StM (Eff (Logs l ': (LogWriterReader l m ': r))) a = StM (Eff r) a

type LogWriterReader message writerM = Reader (LogWriter message writerM)

Type alias for the Reader effect that writes logs

foldingLogWriter :: (forall f. (MonadPlus f, Traversable f, NFData1 f) => f message -> writerM ()) -> LogWriter message writerM

Create a LogWriter from a function that can write a Traversable container.

writeAllLogMessages :: (NFData1 f, MonadPlus f, Traversable f, Applicative writerM) => LogWriter message writerM -> f message -> writerM ()

Efficiently apply the LogWriter to a Traversable container of log messages.

singleMessageLogWriter :: Applicative writerM => (message -> writerM ()) -> LogWriter message writerM

Create a LogWriter from a function that is applied to each individual log message. NOTE: This is probably the simplest, but also the most inefficient and annoying way to make a LogWriter. Better use foldingLogWriter or even multiMessageLogWriter.

multiMessageLogWriter :: Applicative writerM => (((message -> writerM ()) -> writerM ()) -> writerM ()) -> LogWriter message writerM

Create a LogWriter from a function that is applied to each individual log message. Don't be scared by the type signature, here is an example file appender that re-opens the log file everytime a bunch of log messages are written:

fileAppender fn = multiMessageLogWriter
  (\writeLogMessageWith ->
     withFile fn AppendMode (writeLogMessageWith . hPutStrLn))

askLogWriter :: forall m h r. Member (Reader (LogWriter m h)) r => Eff r (LogWriter m h)

Get the current LogWriter

data Logs m v

This effect sends log messages. The logs are not sent one-by-one, but always in batches of containers that must be Traversable and MonadPlus instances. Log messages are consumed by LogWriters installed via runLogs or more high level functions like writeLogs.

Instances

(MonadBase m m, Lifted m r, NFData l, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Logs l ': (LogWriterReader l m ': r)))

This instance allows liftings of the Logs effect, but only, if there is a LogWriter in effect.

Defined in Control.Eff.Log.Handler

Associated Types

type StM (Eff (Logs l ': (LogWriterReader l m ': r))) a :: Type

Methods

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

restoreM :: StM (Eff (Logs l ': (LogWriterReader l m ': r))) a -> Eff (Logs l ': (LogWriterReader l m ': r)) a

(NFData l, Lifted m e, MonadThrow (Eff e)) => MonadThrow (Eff (Logs l ': (LogWriterReader l m ': e)))

Defined in Control.Eff.Log.Handler

Methods

throwM :: Exception e0 => e0 -> Eff (Logs l ': (LogWriterReader l m ': e)) a

(NFData l, Applicative m, Lifted m e, MonadCatch (Eff e)) => MonadCatch (Eff (Logs l ': (LogWriterReader l m ': e)))

Defined in Control.Eff.Log.Handler

Methods

catch :: Exception e0 => Eff (Logs l ': (LogWriterReader l m ': e)) a -> (e0 -> Eff (Logs l ': (LogWriterReader l m ': e)) a) -> Eff (Logs l ': (LogWriterReader l m ': e)) a

(NFData l, Applicative m, Lifted m e, MonadMask (Eff e)) => MonadMask (Eff (Logs l ': (LogWriterReader l m ': e)))

Defined in Control.Eff.Log.Handler

Methods

mask :: ((forall a. Eff (Logs l ': (LogWriterReader l m ': e)) a -> Eff (Logs l ': (LogWriterReader l m ': e)) a) -> Eff (Logs l ': (LogWriterReader l m ': e)) b) -> Eff (Logs l ': (LogWriterReader l m ': e)) b

uninterruptibleMask :: ((forall a. Eff (Logs l ': (LogWriterReader l m ': e)) a -> Eff (Logs l ': (LogWriterReader l m ': e)) a) -> Eff (Logs l ': (LogWriterReader l m ': e)) b) -> Eff (Logs l ': (LogWriterReader l m ': e)) b

generalBracket :: Eff (Logs l ': (LogWriterReader l m ': e)) a -> (a -> ExitCase b -> Eff (Logs l ': (LogWriterReader l m ': e)) c) -> (a -> Eff (Logs l ': (LogWriterReader l m ': e)) b) -> Eff (Logs l ': (LogWriterReader l m ': e)) (b, c)

type StM (Eff (Logs l ': (LogWriterReader l m ': r))) a

Defined in Control.Eff.Log.Handler

type StM (Eff (Logs l ': (LogWriterReader l m ': r))) a = StM (Eff r) a

writeLogs :: forall message writerM r a. (Applicative writerM, Lifted writerM r, NFData message) => LogWriter message writerM -> Eff (Logs message ': (Reader (LogWriter message writerM) ': r)) a -> Eff r a

Handle log message effects by a monadic action, e.g. an IO action to send logs to the console output or a log-server. The monadic log writer action is wrapped in a newtype called LogWriter.

Use the smart constructors below to create them, e.g. foldingLogWriter, singleMessageLogWriter or mulitMessageLogWriter.

runLogs :: forall m h e b. (Applicative h, Lifted h e, Member (LogWriterReader m h) e, NFData m) => Eff (Logs m ': e) b -> Eff e b

Install Logs handler that asks for a LogWriter for the message type and applies the log writer to the messages.