A Message captures a textual component and a metadata component. The metadata component is a list of SeriesElem to support tacking on arbitrary structured data to a log message.

With the OverloadedStrings extension enabled, Message values can be constructed without metadata fairly conveniently, just as if we were using Text directly:

logDebug "Some log message without metadata"

Metadata may be included in a Message via the :# constructor:

logDebug $ "Some log message with metadata" :#
  [ "bloorp" .= (42 :: Int)
  , "bonk" .= ("abc" :: Text)
  ]

The mnemonic for the :# constructor is that the # symbol is sometimes referred to as a hash, a JSON object can be thought of as a hash map, and so with :# (and enough squinting), we are cons-ing a textual message onto a JSON object. Yes, this mnemonic isn't well-typed, but hopefully it still helps!

Since: 0.1.0.0

A single key-value pair, where the value is encoded JSON. This is a more restricted version of Series: a SeriesElem is intended to encapsulate exactly one key-value pair, whereas a Series encapsulates zero or more key-value pairs. SeriesElem values can be created via (.=) from aeson.

While a SeriesElem most often will map to a single pair, note that a Semigroup instance is available for performance's sake. The Semigroup instance is useful when multiple pairs are grouped together and then shared across multiple logging calls. In that case, the cost of combining the pairs in the group must only be paid once.

Since: 0.3.0.0

This type is the Haskell representation of each JSON log message produced by this library.

While we never interact with this type directly when logging messages with monad-logger-aeson, we may wish to use this type if we are parsing/processing log files generated by this library.

Since: 0.1.0.0

Logs a Message with the location provided by an implicit CallStack.

Since: 0.1.0.0

See logDebug

Since: 0.1.0.0

See logDebug

Since: 0.1.0.0

See logDebug

Since: 0.1.0.0

See logDebug

Since: 0.1.0.0

Logs a Message with location given by CallStack.

Since: 0.1.0.0

See logDebugCS

Since: 0.1.0.0

See logDebugCS

Since: 0.1.0.0

See logDebugCS

Since: 0.1.0.0

See logDebugCS

Since: 0.1.0.0

See logDebugCS

Since: 0.1.0.0

See logDebugNS

Since: 0.1.0.0

See logDebugNS

Since: 0.1.0.0

See logDebugNS

Since: 0.1.0.0

See logDebugNS

Since: 0.1.0.0

See logDebug.

This is an alias for logDebug and is provided mainly for symmetry with monad-logger.

Since: 0.4.0.0

See logDebugN

Since: 0.4.0.0

See logDebugN

Since: 0.4.0.0

See logDebugN

Since: 0.4.0.0

See logDebugN

Since: 0.4.0.0

This function lets us register structured, contextual info for the duration of the provided action. All messages logged within the provided action will automatically include this contextual info. This function is thread-safe, as the contextual info is scoped to the calling thread only.

This function is additive: if we nest calls to it, each nested call will add to the existing thread context. In the case of overlapping keys, the nested call's Pair value(s) will win. Whenever the inner action completes, the thread context is rolled back to its value set in the enclosing action.

If we wish to include the existing thread context from one thread in another thread, we must register the thread context explicitly on that other thread. myThreadContext can be leveraged in this case.

Registering thread context for messages can be useful in many scenarios. One particularly apt scenario is in wai middlewares. We can generate an ID for each incoming request then include it in the thread context. Now all messages subsequently logged from our endpoint handler will automatically include that request ID:

import Control.Monad.Logger.Aeson ((.=), withThreadContext)
import Network.Wai (Middleware)
import qualified Data.UUID.V4 as UUID

addRequestId :: Middleware
addRequestId app = \request sendResponse -> do
  uuid <- UUID.nextRandom
  withThreadContext ["requestId" .= uuid] do
    app request sendResponse

If we're coming from a Java background, it may be helpful for us to draw parallels between this function and log4j2's ThreadContext (or perhaps log4j's MDC). They all enable the same thing: setting some thread-local info that will be automatically pulled into each logged message.

Since: 0.1.0.0

This function lets us retrieve the calling thread's thread context. For more detail, we can consult the docs for withThreadContext.

Note that even though the type signature lists MonadThrow as a required constraint, the library guarantees that myThreadContext will never throw.

Since: 0.1.0.0

Run a block using a MonadLogger instance which appends to the specified file.

Note that this differs from the monad-logger version in its constraints. We use the exceptions package's MonadMask here for bracketing, rather than monad-control.

Since: 0.1.0.0

Run a block using a MonadLogger instance which prints to a Handle determined by the log message's LogLevel.

A common use case for this function is to log warn/error messages to stderr and debug/info messages to stdout in CLIs/tools (see defaultHandleFromLevel).

Since: 0.1.0.0

Run a block using a MonadLogger instance which prints to stdout.

Since: 0.1.0.0

Run a block using a MonadLogger instance which prints to stderr.

Since: 0.1.0.0

Run a block using a MonadLogger instance which appends to the specified LoggerSet.

Since: 0.1.0.0

A default implementation of the action that backs the monadLoggerLog function. It accepts a file handle as the first argument and will log incoming LogStr values wrapped in the JSON structure prescribed by this library.

This is used in the definition of runStdoutLoggingT and runStderrLoggingT:

runStdoutLoggingT :: LoggingT m a -> m a
runStdoutLoggingT = flip runLoggingT (defaultOutput stdout)

We can instead use defaultOutputWith if we need more control of the output.

Since: 0.1.0.0

An implementation of the action that backs the monadLoggerLog function, where the Handle destination for each log message is determined by the log message's LogLevel. This function will log incoming LogStr values wrapped in the JSON structure prescribed by this library.

This is used in the definition of runHandleLoggingT:

runHandleLoggingT :: (LogLevel -> Handle) -> LoggingT m a -> m a
runHandleLoggingT = flip runLoggingT . handleOutput

Since: 0.1.0.0

An implementation of the action that backs the monadLoggerLog function, where log messages are written to a provided LoggerSet. This function will log incoming LogStr values wrapped in the JSON structure prescribed by this library.

This is used in the definition of runFastLoggingT:

runFastLoggingT :: LoggerSet -> LoggingT m a -> m a
runFastLoggingT loggerSet = flip runLoggingT (fastLoggerOutput loggerSet)

Since: 0.1.0.0

This function is a lower-level helper for implementing the action that backs the monadLoggerLog function.

We should generally prefer defaultOutput over this function, but this function is available if we do need more control over our output.

Since: 0.1.0.0

Given an output action for log messages, this function will produce the default recommended OutputOptions.

Specific options can be overriden via record update syntax using outputIncludeThreadId, outputBaseThreadContext, and friends.

Since: 0.1.0.0

OutputOptions is for use with defaultOutputWith and enables us to configure the JSON output produced by this library.

We can get a hold of a value of this type via defaultOutputOptions.

Since: 0.1.0.0

Controls whether or not the thread ID is included in each log message's thread context.

Default: False

Since: 0.1.0.0

Allows for setting a "base" thread context, i.e. a set of Pair that will always be present in log messages.

If we subsequently use withThreadContext to register some thread context for our messages, if any of the keys in those Pair values overlap with the "base" thread context, then the overlapped Pair values in the "base" thread context will be overridden for the duration of the action provided to withThreadContext.

Default: mempty

Since: 0.1.0.0

Since: 0.1.0.0

This function maps the possible LogLevel values to Handle values. Specifically, LevelDebug and LevelInfo map to stdout, while LevelWarn and LevelError map to stderr. The function is most useful for CLIs/tools (see runHandleLoggingT).

The input function discriminating Text is used to determine the Handle mapping for LevelOther. For example, if we wish for all LevelOther messages to be logged to stderr, we can supply (const stderr) as the value for this input function.

Since: 0.1.0.0

Types that can be converted to a LogStr. Instances for types from the text library use a UTF-8 encoding. Instances for numerical types use a decimal encoding.

Log message builder. Use (<>) to append two LogStr in O(1).

Monad transformer that adds a new logging function.

Since: monad-logger-0.2.2

Since: monad-logger-0.3.28

Since: monad-logger-0.3.32

Monad transformer that disables logging.

Since: monad-logger-0.2.4

An extension of MonadLogger for the common case where the logging action is a simple IO action. The advantage of using this typeclass is that the logging function itself can be extracted as a first-class value, which can make it easier to manipulate monad transformer stacks, as an example.

Since: monad-logger-0.3.10

A Monad which has the ability to log messages in some manner.

Converting LogStr to ByteString.

Generates a function that takes a 'Show a => a' and logs a LevelDebug message. Usage:

$(logDebugSH) (Just "This is a debug log message")

Since: monad-logger-0.3.18

See logDebugSH

See logDebugSH

See logDebugSH

Generates a function that takes a 'Show a => a' and logs a LevelOther message. Usage:

$(logOtherSH "My new level") "This is a log message"

Lift a location into an Exp.

Since: monad-logger-0.3.1

Generates a function that takes a LogSource and Text and logs a LevelDebug message. Usage:

$logDebugS "SomeSource" "This is a debug log message"

See logDebugS

See logDebugS

See logDebugS

Generates a function that takes a LogSource, a level name and a Text and logs a LevelOther message. Usage:

$logOtherS "SomeSource" "My new level" "This is a log message"

Run a block using a MonadLogger instance. Return a value and logs in a list | @since 0.3.28

Run a block using a MonadLogger instance. Return logs in a list | @since 0.3.28

Run a block using a MonadLogger instance which writes tuples to an unbounded channel.

The tuples can be extracted (ie. in another thread) with unChanLoggingT or a custom extraction funtion, and written to a destination.

Since: monad-logger-0.3.17

Read logging tuples from an unbounded channel and log them into a MonadLoggerIO monad, forever.

For use in a dedicated thread with a channel fed by runChanLoggingT.

Since: monad-logger-0.3.17

Within the LoggingT monad, capture all log messages to a bounded channel of the indicated size, and only actually log them if there is an exception.

Since: monad-logger-0.3.2

Only log messages passing the given predicate function.

This can be a convenient way, for example, to ignore debug level messages.

Since: monad-logger-0.3.13

Map the unwrapped computation using the given function.

Since: monad-logger-0.3.29

Map the unwrapped computation using the given function.

Since: monad-logger-0.3.29

dummy location, used with logWithoutLoc

Since: monad-logger-0.3.23