Effectful.Log

Provide the ability to log messages via MonadLog.

Create a Value from a list of name/value Pairs. If duplicate keys arise, later keys and their associated values win.

Log a message and its associated data using current time as the event time and the LogAttention log level.

Like logAttention, but without any additional associated data.

Log a message and its associated data using current time as the event time and the LogInfo log level.

Like logInfo, but without any additional associated data.

Log a message and its associated data using current time as the event time and the LogTrace log level.

Like logTrace, but without any additional associated data.

The default log level. Returns LogInfo.

This function is partial.

Render a LogMessage to Text.

Execute logger to serialize a LogMessage.

Shutdown the logger thread associated with this Logger object. Subsequent attempts to write messages via this Logger will result in an exception.

Wait until all LogMessages stored in the internal queue are serialized.

Start an asynchronous logger thread that consumes all queued messages once per second.

Note: a bounded queue of size 1000000 is used internally to avoid unrestricted memory consumption.

To make sure that the messages get written out in the presence of exceptions, use high-level wrappers like withLogger, Log.Backend.ElasticSearch.withElasticSearchLogger or withBulkStdOutLogger instead of this function directly.

Note: some messages can be lost when the main thread shuts down without making sure that all logger threads have written out all messages, because in that case child threads are not given a chance to clean up by the RTS. This is apparently a feature: https://mail.haskell.org/pipermail/haskell-cafe/2014-February/112754.html

To work around this issue, make sure that the main thread doesn't exit until all its children have terminated. The async package makes this easy.

Problematic example:

import Control.Concurrent.Async

main :: IO ()
main = do
   logger <- Log.Backend.ElasticSearch.elasticSearchLogger
   a <- Control.Concurrent.Async.async (Log.Backend.ElasticSearch.withElasticSearchLogger $ \logger ->
               runLogT "main" logger defaultLogLevel $ logTrace_ "foo")
   -- Main thread exits without waiting for the child
   -- to finish and without giving the child a chance
   -- to do proper cleanup.

Fixed example:

import Control.Concurrent.Async

main :: IO ()
main = do
   logger <- Log.Backend.ElasticSearch.elasticSearchLogger
   a <- Control.Concurrent.Async.async (Log.Backend.ElasticSearch.withElasticSearchLogger $ \logger ->
               runLogT "main" logger defaultLogLevel $ logTrace_ "foo")
   Control.Concurrent.Async.wait a
   -- Main thread waits for the child to finish, giving
   -- it a chance to shut down properly. This works even
   -- in the presence of exceptions in the child thread.

Like mkBulkLogger, but with configurable queue size and thread delay.

Start a logger thread that consumes one queued message at a time.

Note: a bounded queue of size 1000000 is used internally to avoid unrestricted memory consumption.

Like mkBulkLogger, but with configurable queue size.

Return an IO action that logs messages using the current MonadLog context. Useful for interfacing with libraries such as aws or amazonka that accept logging callbacks operating in IO.

Ensure uncaught exceptions get logged. Convenient to compose right after runLogT so any exception will show up.

Base implementation of logMessage for use with a specific LoggerEnv. Useful for reimplementation of MonadLog instance.

Transform the computation inside a LogT.

Run a LogT computation.

Note that in the case of asynchronous/bulk loggers runLogT doesn't guarantee that all messages are actually written to the log once it finishes. Use withPGLogger or withElasticSearchLogger for that.

Represents the family of monads with logging capabilities. Each MonadLog carries with it some associated state (the logging environment) that can be modified locally with localData and localDomain.

Available log levels. Note that ordering in this definintion determines what the maximum log level is. See Log.Monad.leMaxLogLevel.

Represents message to be logged.

An object used for communication with a logger thread that outputs LogMessages using e.g. PostgreSQL, Elasticsearch or stdout (depending on the back-end chosen).

The state that every LogT carries around.

Monad transformer that adds logging capabilities to the underlying monad.

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.