Control.Monad.Logger

This module provides the facilities needed for a decoupled logging system.

The MonadLogger class is implemented by monads that give access to a logging facility. If you're defining a custom monad, then you may define an instance of MonadLogger that routes the log messages to the appropriate place (e.g., that's what yesod-core's HandlerT does). Otherwise, you may use the LoggingT monad included in this module (see runStderrLoggingT). To simply discard log message, use NoLoggingT.

As a user of the logging facility, we provide you some convenient Template Haskell splices that use the MonadLogger class. They will record their source file and position, which is very helpful when debugging. See logDebug for more information.

MonadLogger

class Monad m => MonadLogger m where

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

Minimal complete definition

Nothing

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> m ()

default monadLoggerLog :: (MonadLogger m', MonadTrans t, MonadLogger (t m'), ToLogStr msg, m ~ t m') => Loc -> LogSource -> LogLevel -> msg -> m ()

Instances

MonadLogger m => MonadLogger (MaybeT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> MaybeT m ()

MonadLogger m => MonadLogger (ResourceT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ResourceT m ()

MonadLogger m => MonadLogger (ListT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ListT m ()

MonadIO m => MonadLogger (LoggingT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> LoggingT m ()

Monad m => MonadLogger (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WriterLoggingT m ()

Monad m => MonadLogger (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> NoLoggingT m ()

(MonadLogger m, Monoid w) => MonadLogger (WriterT w m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WriterT w m ()

(MonadLogger m, Monoid w) => MonadLogger (WriterT w m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WriterT w m ()

MonadLogger m => MonadLogger (StateT s m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> StateT s m ()

MonadLogger m => MonadLogger (StateT s m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> StateT s m ()

MonadLogger m => MonadLogger (ReaderT r m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ReaderT r m ()

MonadLogger m => MonadLogger (ExceptT e m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ExceptT e m ()

(MonadLogger m, Error e) => MonadLogger (ErrorT e m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ErrorT e m ()

MonadLogger m => MonadLogger (IdentityT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> IdentityT m ()

MonadLogger m => MonadLogger (ConduitM i o m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ConduitM i o m ()

MonadLogger m => MonadLogger (ContT r m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ContT r m ()

(MonadLogger m, Monoid w) => MonadLogger (RWST r w s m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> RWST r w s m ()

(MonadLogger m, Monoid w) => MonadLogger (RWST r w s m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> RWST r w s m ()

MonadLogger m => MonadLogger (Pipe l i o u m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> Pipe l i o u m ()

class (MonadLogger m, MonadIO m) => MonadLoggerIO m where

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: 0.3.10

Minimal complete definition

Nothing

Methods

askLoggerIO :: m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

Request the logging function itself.

Since: 0.3.10

default askLoggerIO :: (MonadTrans t, MonadLoggerIO n, m ~ t n) => m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

Instances

MonadLoggerIO m => MonadLoggerIO (MaybeT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: MaybeT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (ResourceT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ResourceT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (ListT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ListT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadIO m => MonadLoggerIO (LoggingT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: LoggingT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadIO m => MonadLoggerIO (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: NoLoggingT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

(MonadLoggerIO m, Monoid w) => MonadLoggerIO (WriterT w m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: WriterT w m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

(MonadLoggerIO m, Monoid w) => MonadLoggerIO (WriterT w m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: WriterT w m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (StateT s m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: StateT s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (StateT s m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: StateT s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (ReaderT r m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ReaderT r m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (ExceptT e m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ExceptT e m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

(MonadLoggerIO m, Error e) => MonadLoggerIO (ErrorT e m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ErrorT e m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (IdentityT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: IdentityT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (ConduitM i o m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ConduitM i o m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (ContT r m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: ContT r m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

(MonadLoggerIO m, Monoid w) => MonadLoggerIO (RWST r w s m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: RWST r w s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

(MonadLoggerIO m, Monoid w) => MonadLoggerIO (RWST r w s m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: RWST r w s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadLoggerIO m => MonadLoggerIO (Pipe l i o u m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: Pipe l i o u m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

data LogLevel

Constructors

LevelDebug

LevelInfo

LevelWarn

LevelError

LevelOther Text

Instances

Eq LogLevel

Defined in Control.Monad.Logger

Methods

(==) :: LogLevel -> LogLevel -> Bool

(/=) :: LogLevel -> LogLevel -> Bool

Ord LogLevel

Defined in Control.Monad.Logger

Methods

compare :: LogLevel -> LogLevel -> Ordering

(<) :: LogLevel -> LogLevel -> Bool

(<=) :: LogLevel -> LogLevel -> Bool

(>) :: LogLevel -> LogLevel -> Bool

(>=) :: LogLevel -> LogLevel -> Bool

max :: LogLevel -> LogLevel -> LogLevel

min :: LogLevel -> LogLevel -> LogLevel

Read LogLevel

Defined in Control.Monad.Logger

Methods

readsPrec :: Int -> ReadS LogLevel

readList :: ReadS [LogLevel]

readPrec :: ReadPrec LogLevel

readListPrec :: ReadPrec [LogLevel]

Show LogLevel

Defined in Control.Monad.Logger

Methods

showsPrec :: Int -> LogLevel -> ShowS

show :: LogLevel -> String

showList :: [LogLevel] -> ShowS

Lift LogLevel

Defined in Control.Monad.Logger

Methods

lift :: LogLevel -> Q Exp

liftTyped :: LogLevel -> Q (TExp LogLevel)

type LogLine = (Loc, LogSource, LogLevel, LogStr)

Since: 0.3.32

type LogSource = Text

Re-export from fast-logger

data LogStr

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

Instances

Eq LogStr

Defined in System.Log.FastLogger.LogStr

Methods

(==) :: LogStr -> LogStr -> Bool

(/=) :: LogStr -> LogStr -> Bool

Show LogStr

Defined in System.Log.FastLogger.LogStr

Methods

showsPrec :: Int -> LogStr -> ShowS

show :: LogStr -> String

showList :: [LogStr] -> ShowS

IsString LogStr

Defined in System.Log.FastLogger.LogStr

Methods

fromString :: String -> LogStr

Semigroup LogStr

Defined in System.Log.FastLogger.LogStr

Methods

(<>) :: LogStr -> LogStr -> LogStr

sconcat :: NonEmpty LogStr -> LogStr

stimes :: Integral b => b -> LogStr -> LogStr

Monoid LogStr

Defined in System.Log.FastLogger.LogStr

Methods

mempty :: LogStr

mappend :: LogStr -> LogStr -> LogStr

mconcat :: [LogStr] -> LogStr

ToLogStr LogStr

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: LogStr -> LogStr

class ToLogStr msg where

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.

Methods

toLogStr :: msg -> LogStr

Instances

ToLogStr Double

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Double -> LogStr

ToLogStr Float

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Float -> LogStr

ToLogStr Int

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Int -> LogStr

ToLogStr Int8

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Int8 -> LogStr

ToLogStr Int16

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Int16 -> LogStr

ToLogStr Int32

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Int32 -> LogStr

ToLogStr Int64

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Int64 -> LogStr

ToLogStr Integer

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Integer -> LogStr

ToLogStr Word

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Word -> LogStr

ToLogStr Word8

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Word8 -> LogStr

ToLogStr Word16

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Word16 -> LogStr

ToLogStr Word32

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Word32 -> LogStr

ToLogStr Word64

Since: fast-logger-2.4.14

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Word64 -> LogStr

ToLogStr ByteString

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: ByteString -> LogStr

ToLogStr ByteString

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: ByteString -> LogStr

ToLogStr Text

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Text -> LogStr

ToLogStr Text

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Text -> LogStr

ToLogStr String

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: String -> LogStr

ToLogStr Builder

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Builder -> LogStr

ToLogStr LogStr

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: LogStr -> LogStr

fromLogStr :: LogStr -> ByteString

Converting LogStr to ByteString.

Helper transformers

newtype LoggingT m a

Monad transformer that adds a new logging function.

Since: 0.2.2

Constructors

LoggingT

Fields

• runLoggingT :: (Loc -> LogSource -> LogLevel -> LogStr -> IO ()) -> m a

Instances

MonadTrans LoggingT

Defined in Control.Monad.Logger

Methods

lift :: Monad m => m a -> LoggingT m a

MonadTransControl LoggingT

Defined in Control.Monad.Logger

Associated Types

type StT LoggingT a

Methods

liftWith :: Monad m => (Run LoggingT -> m a) -> LoggingT m a

restoreT :: Monad m => m (StT LoggingT a) -> LoggingT m a

MonadRWS r w s m => MonadRWS r w s (LoggingT m)

Defined in Control.Monad.Logger

MonadBase b m => MonadBase b (LoggingT m)

Defined in Control.Monad.Logger

Methods

liftBase :: b α -> LoggingT m α

MonadBaseControl b m => MonadBaseControl b (LoggingT m)

Defined in Control.Monad.Logger

Associated Types

type StM (LoggingT m) a

Methods

liftBaseWith :: (RunInBase (LoggingT m) b -> b a) -> LoggingT m a

restoreM :: StM (LoggingT m) a -> LoggingT m a

MonadWriter w m => MonadWriter w (LoggingT m)

Defined in Control.Monad.Logger

Methods

writer :: (a, w) -> LoggingT m a

tell :: w -> LoggingT m ()

listen :: LoggingT m a -> LoggingT m (a, w)

pass :: LoggingT m (a, w -> w) -> LoggingT m a

MonadState s m => MonadState s (LoggingT m)

Defined in Control.Monad.Logger

Methods

get :: LoggingT m s

put :: s -> LoggingT m ()

state :: (s -> (a, s)) -> LoggingT m a

MonadReader r m => MonadReader r (LoggingT m)

Defined in Control.Monad.Logger

Methods

ask :: LoggingT m r

local :: (r -> r) -> LoggingT m a -> LoggingT m a

reader :: (r -> a) -> LoggingT m a

MonadError e m => MonadError e (LoggingT m)

Defined in Control.Monad.Logger

Methods

throwError :: e -> LoggingT m a

catchError :: LoggingT m a -> (e -> LoggingT m a) -> LoggingT m a

Monad m => Monad (LoggingT m)

Defined in Control.Monad.Logger

Methods

(>>=) :: LoggingT m a -> (a -> LoggingT m b) -> LoggingT m b

(>>) :: LoggingT m a -> LoggingT m b -> LoggingT m b

return :: a -> LoggingT m a

Functor m => Functor (LoggingT m)

Defined in Control.Monad.Logger

Methods

fmap :: (a -> b) -> LoggingT m a -> LoggingT m b

(<$) :: a -> LoggingT m b -> LoggingT m a

MonadFail m => MonadFail (LoggingT m)

Since: 0.3.30

Defined in Control.Monad.Logger

Methods

fail :: String -> LoggingT m a

Applicative m => Applicative (LoggingT m)

Defined in Control.Monad.Logger

Methods

pure :: a -> LoggingT m a

(<*>) :: LoggingT m (a -> b) -> LoggingT m a -> LoggingT m b

liftA2 :: (a -> b -> c) -> LoggingT m a -> LoggingT m b -> LoggingT m c

(*>) :: LoggingT m a -> LoggingT m b -> LoggingT m b

(<*) :: LoggingT m a -> LoggingT m b -> LoggingT m a

MonadIO m => MonadIO (LoggingT m)

Defined in Control.Monad.Logger

Methods

liftIO :: IO a -> LoggingT m a

MonadUnliftIO m => MonadUnliftIO (LoggingT m)

Since: 0.3.26

Defined in Control.Monad.Logger

Methods

withRunInIO :: ((forall a. LoggingT m a -> IO a) -> IO b) -> LoggingT m b

MonadResource m => MonadResource (LoggingT m)

Defined in Control.Monad.Logger

Methods

liftResourceT :: ResourceT IO a -> LoggingT m a

MonadThrow m => MonadThrow (LoggingT m)

Defined in Control.Monad.Logger

Methods

throwM :: Exception e => e -> LoggingT m a

MonadActive m => MonadActive (LoggingT m)

Defined in Control.Monad.Logger

Methods

monadActive :: LoggingT m Bool

MonadCatch m => MonadCatch (LoggingT m)

Defined in Control.Monad.Logger

Methods

catch :: Exception e => LoggingT m a -> (e -> LoggingT m a) -> LoggingT m a

MonadMask m => MonadMask (LoggingT m)

Defined in Control.Monad.Logger

Methods

mask :: ((forall a. LoggingT m a -> LoggingT m a) -> LoggingT m b) -> LoggingT m b

uninterruptibleMask :: ((forall a. LoggingT m a -> LoggingT m a) -> LoggingT m b) -> LoggingT m b

generalBracket :: LoggingT m a -> (a -> ExitCase b -> LoggingT m c) -> (a -> LoggingT m b) -> LoggingT m (b, c)

MonadCont m => MonadCont (LoggingT m)

Defined in Control.Monad.Logger

Methods

callCC :: ((a -> LoggingT m b) -> LoggingT m a) -> LoggingT m a

MonadIO m => MonadLoggerIO (LoggingT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: LoggingT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

MonadIO m => MonadLogger (LoggingT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> LoggingT m ()

type StT LoggingT a

Defined in Control.Monad.Logger

type StT LoggingT a = a

type StM (LoggingT m) a

Defined in Control.Monad.Logger

type StM (LoggingT m) a = StM m a

runStderrLoggingT :: MonadIO m => LoggingT m a -> m a

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

Since: 0.2.2

runStdoutLoggingT :: MonadIO m => LoggingT m a -> m a

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

Since: 0.2.2

runChanLoggingT :: MonadIO m => Chan LogLine -> LoggingT m a -> m a

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: 0.3.17

runFileLoggingT :: MonadBaseControl IO m => FilePath -> LoggingT m a -> m a

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

Since: 0.3.22

unChanLoggingT :: (MonadLogger m, MonadIO m) => Chan LogLine -> m void

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: 0.3.17

withChannelLogger

Arguments

:: (MonadBaseControl IO m, MonadIO m)

=> Int

Number of messages to keep

-> LoggingT m a

-> LoggingT m a

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: 0.3.2

filterLogger :: (LogSource -> LogLevel -> Bool) -> LoggingT m a -> LoggingT m a

Only log messages passing the given predicate function.

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

Since: 0.3.13

newtype NoLoggingT m a

Monad transformer that disables logging.

Since: 0.2.4

Constructors

NoLoggingT

Fields

• runNoLoggingT :: m a

Instances

MonadTrans NoLoggingT

Defined in Control.Monad.Logger

Methods

lift :: Monad m => m a -> NoLoggingT m a

MonadTransControl NoLoggingT

Defined in Control.Monad.Logger

Associated Types

type StT NoLoggingT a

Methods

liftWith :: Monad m => (Run NoLoggingT -> m a) -> NoLoggingT m a

restoreT :: Monad m => m (StT NoLoggingT a) -> NoLoggingT m a

MonadBase b m => MonadBase b (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

liftBase :: b α -> NoLoggingT m α

MonadBaseControl b m => MonadBaseControl b (NoLoggingT m)

Defined in Control.Monad.Logger

Associated Types

type StM (NoLoggingT m) a

Methods

liftBaseWith :: (RunInBase (NoLoggingT m) b -> b a) -> NoLoggingT m a

restoreM :: StM (NoLoggingT m) a -> NoLoggingT m a

MonadWriter w m => MonadWriter w (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

writer :: (a, w) -> NoLoggingT m a

tell :: w -> NoLoggingT m ()

listen :: NoLoggingT m a -> NoLoggingT m (a, w)

pass :: NoLoggingT m (a, w -> w) -> NoLoggingT m a

MonadState s m => MonadState s (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

get :: NoLoggingT m s

put :: s -> NoLoggingT m ()

state :: (s -> (a, s)) -> NoLoggingT m a

MonadReader r m => MonadReader r (NoLoggingT m)

Since: 0.3.24

Defined in Control.Monad.Logger

Methods

ask :: NoLoggingT m r

local :: (r -> r) -> NoLoggingT m a -> NoLoggingT m a

reader :: (r -> a) -> NoLoggingT m a

MonadError e m => MonadError e (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

throwError :: e -> NoLoggingT m a

catchError :: NoLoggingT m a -> (e -> NoLoggingT m a) -> NoLoggingT m a

Monad m => Monad (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

(>>=) :: NoLoggingT m a -> (a -> NoLoggingT m b) -> NoLoggingT m b

(>>) :: NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m b

return :: a -> NoLoggingT m a

Functor m => Functor (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

fmap :: (a -> b) -> NoLoggingT m a -> NoLoggingT m b

(<$) :: a -> NoLoggingT m b -> NoLoggingT m a

MonadFail m => MonadFail (NoLoggingT m)

Since: 0.3.30

Defined in Control.Monad.Logger

Methods

fail :: String -> NoLoggingT m a

Applicative m => Applicative (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

pure :: a -> NoLoggingT m a

(<*>) :: NoLoggingT m (a -> b) -> NoLoggingT m a -> NoLoggingT m b

liftA2 :: (a -> b -> c) -> NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m c

(*>) :: NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m b

(<*) :: NoLoggingT m a -> NoLoggingT m b -> NoLoggingT m a

MonadIO m => MonadIO (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

liftIO :: IO a -> NoLoggingT m a

MonadUnliftIO m => MonadUnliftIO (NoLoggingT m)

Since: 0.3.26

Defined in Control.Monad.Logger

Methods

withRunInIO :: ((forall a. NoLoggingT m a -> IO a) -> IO b) -> NoLoggingT m b

MonadResource m => MonadResource (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

liftResourceT :: ResourceT IO a -> NoLoggingT m a

MonadThrow m => MonadThrow (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

throwM :: Exception e => e -> NoLoggingT m a

MonadActive m => MonadActive (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

monadActive :: NoLoggingT m Bool

MonadCatch m => MonadCatch (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

catch :: Exception e => NoLoggingT m a -> (e -> NoLoggingT m a) -> NoLoggingT m a

MonadMask m => MonadMask (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

mask :: ((forall a. NoLoggingT m a -> NoLoggingT m a) -> NoLoggingT m b) -> NoLoggingT m b

uninterruptibleMask :: ((forall a. NoLoggingT m a -> NoLoggingT m a) -> NoLoggingT m b) -> NoLoggingT m b

generalBracket :: NoLoggingT m a -> (a -> ExitCase b -> NoLoggingT m c) -> (a -> NoLoggingT m b) -> NoLoggingT m (b, c)

MonadIO m => MonadLoggerIO (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

askLoggerIO :: NoLoggingT m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())

Monad m => MonadLogger (NoLoggingT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> NoLoggingT m ()

type StT NoLoggingT a

Defined in Control.Monad.Logger

type StT NoLoggingT a = a

type StM (NoLoggingT m) a

Defined in Control.Monad.Logger

type StM (NoLoggingT m) a = StM m a

mapNoLoggingT :: (m a -> n b) -> NoLoggingT m a -> NoLoggingT n b

Map the unwrapped computation using the given function.

Since: 0.3.29

newtype WriterLoggingT m a

Since: 0.3.28

Constructors

WriterLoggingT

Fields

• unWriterLoggingT :: m (a, DList LogLine)

Instances

MonadTrans WriterLoggingT

Defined in Control.Monad.Logger

Methods

lift :: Monad m => m a -> WriterLoggingT m a

MonadTransControl WriterLoggingT

Defined in Control.Monad.Logger

Associated Types

type StT WriterLoggingT a

Methods

liftWith :: Monad m => (Run WriterLoggingT -> m a) -> WriterLoggingT m a

restoreT :: Monad m => m (StT WriterLoggingT a) -> WriterLoggingT m a

MonadBase b m => MonadBase b (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

liftBase :: b α -> WriterLoggingT m α

MonadBaseControl b m => MonadBaseControl b (WriterLoggingT m)

Defined in Control.Monad.Logger

Associated Types

type StM (WriterLoggingT m) a

Methods

liftBaseWith :: (RunInBase (WriterLoggingT m) b -> b a) -> WriterLoggingT m a

restoreM :: StM (WriterLoggingT m) a -> WriterLoggingT m a

Monad m => Monad (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

(>>=) :: WriterLoggingT m a -> (a -> WriterLoggingT m b) -> WriterLoggingT m b

(>>) :: WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m b

return :: a -> WriterLoggingT m a

Functor m => Functor (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

fmap :: (a -> b) -> WriterLoggingT m a -> WriterLoggingT m b

(<$) :: a -> WriterLoggingT m b -> WriterLoggingT m a

Applicative m => Applicative (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

pure :: a -> WriterLoggingT m a

(<*>) :: WriterLoggingT m (a -> b) -> WriterLoggingT m a -> WriterLoggingT m b

liftA2 :: (a -> b -> c) -> WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m c

(*>) :: WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m b

(<*) :: WriterLoggingT m a -> WriterLoggingT m b -> WriterLoggingT m a

MonadIO m => MonadIO (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

liftIO :: IO a -> WriterLoggingT m a

MonadThrow m => MonadThrow (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

throwM :: Exception e => e -> WriterLoggingT m a

MonadCatch m => MonadCatch (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

catch :: Exception e => WriterLoggingT m a -> (e -> WriterLoggingT m a) -> WriterLoggingT m a

MonadMask m => MonadMask (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

mask :: ((forall a. WriterLoggingT m a -> WriterLoggingT m a) -> WriterLoggingT m b) -> WriterLoggingT m b

uninterruptibleMask :: ((forall a. WriterLoggingT m a -> WriterLoggingT m a) -> WriterLoggingT m b) -> WriterLoggingT m b

generalBracket :: WriterLoggingT m a -> (a -> ExitCase b -> WriterLoggingT m c) -> (a -> WriterLoggingT m b) -> WriterLoggingT m (b, c)

Monad m => MonadLogger (WriterLoggingT m)

Defined in Control.Monad.Logger

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WriterLoggingT m ()

type StT WriterLoggingT a

Defined in Control.Monad.Logger

type StT WriterLoggingT a

type StM (WriterLoggingT m) a

Defined in Control.Monad.Logger

type StM (WriterLoggingT m) a = ComposeSt WriterLoggingT m a

execWriterLoggingT :: Functor m => WriterLoggingT m a -> m [LogLine]

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

runWriterLoggingT :: Functor m => WriterLoggingT m a -> m (a, [LogLine])

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

mapLoggingT :: (m a -> n b) -> LoggingT m a -> LoggingT n b

Map the unwrapped computation using the given function.

Since: 0.3.29

TH logging

logDebug :: Q Exp

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

$(logDebug) "This is a debug log message"

logInfo :: Q Exp

See logDebug

logWarn :: Q Exp

See logDebug

logError :: Q Exp

See logDebug

logOther :: Text -> Q Exp

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

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

TH logging of showable values

logDebugSH :: Q Exp

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

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

Since: 0.3.18

logInfoSH :: Q Exp

See logDebugSH

logWarnSH :: Q Exp

See logDebugSH

logErrorSH :: Q Exp

See logDebugSH

logOtherSH :: Text -> Q Exp

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

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

TH logging with source

logDebugS :: Q Exp

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

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

logInfoS :: Q Exp

See logDebugS

logWarnS :: Q Exp

See logDebugS

logErrorS :: Q Exp

See logDebugS

logOtherS :: Q Exp

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"

TH util

liftLoc :: Loc -> Q Exp

Lift a location into an Exp.

Since: 0.3.1

Non-TH logging

logDebugN :: MonadLogger m => Text -> m ()

logInfoN :: MonadLogger m => Text -> m ()

logWarnN :: MonadLogger m => Text -> m ()

logErrorN :: MonadLogger m => Text -> m ()

logOtherN :: MonadLogger m => LogLevel -> Text -> m ()

Non-TH logging with source

logWithoutLoc :: (MonadLogger m, ToLogStr msg) => LogSource -> LogLevel -> msg -> m ()

Since: 0.3.23

logDebugNS :: MonadLogger m => LogSource -> Text -> m ()

logInfoNS :: MonadLogger m => LogSource -> Text -> m ()

logWarnNS :: MonadLogger m => LogSource -> Text -> m ()

logErrorNS :: MonadLogger m => LogSource -> Text -> m ()

logOtherNS :: MonadLogger m => LogSource -> LogLevel -> Text -> m ()

Callstack logging

logDebugCS :: MonadLogger m => CallStack -> Text -> m ()

Logs a message with location given by CallStack. See CallStack for more convenient functions for CallStack based logging.

Since: 0.3.19

logInfoCS :: MonadLogger m => CallStack -> Text -> m ()

See logDebugCS

Since: 0.3.19

logWarnCS :: MonadLogger m => CallStack -> Text -> m ()

See logDebugCS

Since: 0.3.19

logErrorCS :: MonadLogger m => CallStack -> Text -> m ()

See logDebugCS

Since: 0.3.19

logOtherCS :: MonadLogger m => CallStack -> LogLevel -> Text -> m ()

See logDebugCS

Since: 0.3.19

utilities for defining your own loggers

defaultLogStr :: Loc -> LogSource -> LogLevel -> LogStr -> LogStr

Loc

When monad-logger is compiled with the template_haskell flag set to true (the default), the Loc below is a re-export from the template-haskell package. When the flag is false, the Loc below is a copy of that data structure defined in monad-logger itself.

If you are making a library that:

• Uses monad-logger
• Uses Loc in a type signature
• But doesn't need to depend on template-haskell for other reasons

You can import Loc directly from this package, instead of adding an dependency on template-haskell and importing from there. This allows users to compile your package in environments that don't support template-haskell.

data Loc

Constructors

Loc

Fields

• loc_filename :: String
• loc_package :: String
• loc_module :: String
• loc_start :: CharPos
• loc_end :: CharPos

Instances

Eq Loc

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Loc -> Loc -> Bool

(/=) :: Loc -> Loc -> Bool

Data Loc

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc

toConstr :: Loc -> Constr

dataTypeOf :: Loc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)

gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r

gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc

Ord Loc

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Loc -> Loc -> Ordering

(<) :: Loc -> Loc -> Bool

(<=) :: Loc -> Loc -> Bool

(>) :: Loc -> Loc -> Bool

(>=) :: Loc -> Loc -> Bool

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Show Loc

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Loc -> ShowS

show :: Loc -> String

showList :: [Loc] -> ShowS

Generic Loc

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Loc :: Type -> Type

Methods

from :: Loc -> Rep Loc x

to :: Rep Loc x -> Loc

type Rep Loc

Defined in Language.Haskell.TH.Syntax

type Rep Loc = D1 ('MetaData "Loc" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Loc" 'PrefixI 'True) ((S1 ('MetaSel ('Just "loc_filename") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "loc_package") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :*: (S1 ('MetaSel ('Just "loc_module") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Just "loc_start") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CharPos) :*: S1 ('MetaSel ('Just "loc_end") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CharPos)))))

defaultLoc :: Loc

dummy location, used with logWithoutLoc

Since: 0.3.23

defaultOutput :: Handle -> Loc -> LogSource -> LogLevel -> LogStr -> IO ()

A default implementation of monadLoggerLog that accepts a file handle as the first argument.

This is used in the definition of runStdoutLoggingT:

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

Since: 0.3.36