The LogAction holds the ability to log a message of type msg (the second parameter) via a monad m (the first parameter).

LogActions are semigroup and monoid combineable, which results in both LogActions being taken (or no action in the case of mempty), and contravariant to allow the msg to be modified via function prior to being logged (as well as Divisible and Decidable).

Any monad which will support retrieving or adjusting a LogAction must support the HasLog class.

This invokes the LogAction's logging handler in a monadic context where the logging handler can be retrieved via the HasLog class's getLogAction function.

Ensures that the LogAction does not fail if the logging operation itself throws an exception (the exception is ignored).

The logFilter can be used on a LogAction to determine which messages the LogAction should be invoked for (only those for which the filter function returns True).

The Severity indicates the relative importance of the logging message. This can be useful for filtering log messages.

The LogType indicates what type of message this is. These are printed on the log line and can be used for filtering different types of log messages.

Each logged output is described by a LogMessage object.

Helper routine to return an empty LogMessage, whose fields can then be updated.

This type is a Constraint that should be applied to any client function that will perform logging in a monad context. The msg is the type of message that will be logged, and the m is the monad under which the logging is performed.

Log messages can have any number of key/value tags applied to them. This function establishes a new key/value tag pair that will be in effect for the monadic operation passed as the third argument. withLogTag tname tval op = local (adjustLogAction $ addLogTag tname tval) op

Add the current timestamp to the LogMessage being logged

Standard function for converting a LogMessage into plain Text (no colors or bolding, just text). This can be used as the default converter for a logger (via contramap).

Standard function to convert a LogMessage into Text with ANSI terminal colors and bolding and other styling. This can be used as the default converter for a logger (via contramap).

A wrapper for a monadic function call that will log on entry (Debug) and exit (Info) from the function, and note the total amount of time taken during execution of the function. Note that no strictness is applied to the internal monadic operation, so the time taken may be misleading. Like logFunctionCallM but needs an explicit LogAction whereas logFunctionCallM will retrieve the LogAction from the current monadic context.

A wrapper for a monadic function call that will log on entry (Debug) and exit (Info) from the function, and note the total amount of time taken during execution of the function. Note that no strictness is applied to the internal monadic operation, so the time taken may be misleading.

Called to output a log message to indicate that some progress has been made.

Called to output a log message within a Logging monad to indicate that some progress has been made.

This is a helper because the LogMessage normally wants a Text, but show delivers a String.

When using a simple IO monad, there is no ability to store a LogAction in the base monad. The client can specify a specific HasLog instance for IO that is appropriate to that client, and that HasLog can optionally use the defaultGetIOLogAction as the getLogAction implementation to log pretty messages with ANSI styling to stdout.

instance HasLog Env Text IO where
    getLogAction = return defaultGetIOLogAction
    ...