Documentation

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

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

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

Map a pure function over log messages.

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")

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)

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.

Throw away all log messages.

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

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

Type alias for the Reader effect that writes logs

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

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

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.

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))

Get the current LogWriter

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.

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.

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