Log.Logger

The Logger type of logging back-ends.

Documentation

data LoggerEnv

The state that every LogT carries around.

Constructors

LoggerEnv

Fields

• leLogger :: !Logger

  The Logger to use.

• leComponent :: !Text

  Current application component.

• leDomain :: ![Text]

  Current application domain.

• leData :: ![Pair]

  Additional data to be merged with the log message's data.

data Logger

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

Instances

Semigroup Logger

Defined in Log.Internal.Logger

Methods

(<>) :: Logger -> Logger -> Logger

sconcat :: NonEmpty Logger -> Logger

stimes :: Integral b => b -> Logger -> Logger

Monoid Logger

Composition of Logger objects.

Defined in Log.Internal.Logger

Methods

mempty :: Logger

mappend :: Logger -> Logger -> Logger

mconcat :: [Logger] -> Logger

mkLogger :: Text -> (LogMessage -> IO ()) -> IO Logger

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

mkBulkLogger :: Text -> ([LogMessage] -> IO ()) -> IO () -> IO Logger

Start an asynchronous logger thread that consumes all queued messages once per second. Uses a bounded queue internally to avoid space leaks. To make sure that the messages get written out in the presence of exceptions, use high-level wrappers like withLogger, 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 <- elasticSearchLogger
   a <- async (withElasticSearchLogger $ \logger ->
               runLogT "main" logger $ 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 <- elasticSearchLogger
   a <- async (withElasticSearchLogger $ \logger ->
               runLogT "main" logger $ logTrace_ "foo")
   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.

mkBulkLogger'

Arguments

:: Int

queue capacity (default 1000000)

-> Int

thread delay (microseconds, default 1000000)

-> Text

logger name

-> ([LogMessage] -> IO ())

write

-> IO ()

flush

-> IO Logger

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

Since: 0.7.4.0

execLogger :: Logger -> LogMessage -> IO ()

Execute logger to serialize a LogMessage.

waitForLogger :: Logger -> IO ()

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

shutdownLogger :: Logger -> IO ()

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