System.Wlog.PureLogging

This module supports pure logging.

Pure logging manipulation

newtype PureLogger m a

Pure implementation of CanLog type class. Instead of writing log messages into console it appends log messages into StateT log. It uses DList for better performance, because messages can be added only at the end of log. But it uses unsafePerformIO so use with caution within IO.

TODO: Should we use some Data.Tree-like structure to observe message only by chosen logger names?

Constructors

PureLogger

Fields

• runPureLogger :: StateT (Seq LogEvent) m a

Instances

MonadTrans PureLogger

Methods

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

Monad m => Monad (PureLogger m)

Methods

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

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

return :: a -> PureLogger m a

fail :: String -> PureLogger m a

Functor m => Functor (PureLogger m)

Methods

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

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

Monad m => Applicative (PureLogger m)

Methods

pure :: a -> PureLogger m a

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

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

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

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

MonadThrow m => MonadThrow (PureLogger m)

Methods

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

(HasLoggerName m, Monad m) => HasLoggerName (PureLogger m)

Methods

askLoggerName :: PureLogger m LoggerName

modifyLoggerName :: (LoggerName -> LoggerName) -> PureLogger m a -> PureLogger m a

Monad m => CanLog (PureLogger m)

Methods

dispatchMessage :: LoggerName -> Severity -> Text -> PureLogger m ()

MFunctor * PureLogger

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b

Monad m => MonadState (Seq LogEvent) (PureLogger m)

Methods

get :: PureLogger m (Seq LogEvent)

put :: Seq LogEvent -> PureLogger m ()

state :: (Seq LogEvent -> (a, Seq LogEvent)) -> PureLogger m a

data LogEvent

Holds all required information for dispatchLoggerName function.

Constructors

LogEvent

Fields

• leLoggerName :: !LoggerName
• leSeverity :: !Severity
• leMessage :: !Text

Instances

Show LogEvent

Methods

showsPrec :: Int -> LogEvent -> ShowS

show :: LogEvent -> String

showList :: [LogEvent] -> ShowS

Monad m => MonadState (Seq LogEvent) (NamedPureLogger m)

Methods

get :: NamedPureLogger m (Seq LogEvent)

put :: Seq LogEvent -> NamedPureLogger m ()

state :: (Seq LogEvent -> (a, Seq LogEvent)) -> NamedPureLogger m a

Monad m => MonadState (Seq LogEvent) (PureLogger m)

Methods

get :: PureLogger m (Seq LogEvent)

put :: Seq LogEvent -> PureLogger m ()

state :: (Seq LogEvent -> (a, Seq LogEvent)) -> PureLogger m a

dispatchEvents :: CanLog m => [LogEvent] -> m ()

Logs all LogEvent's from given list. This function supposed to be used after runPureLog.

logEvents :: WithLogger m => [LogEvent] -> m ()

Logs all LogEvent's from given list. Just like dispatchEvents but uses proper logger Name.

runPureLog :: Functor m => PureLogger m a -> m (a, [LogEvent])

Return log of pure logging action as list of LogEvent.

launchPureLog :: (CanLog n, Monad m) => (forall f. Functor f => m (f a) -> n (f b)) -> PureLogger m a -> n b

Performs actual logging once given action completes.

newtype NamedPureLogger m a

Constructors

NamedPureLogger

Fields

• runNamedPureLogger :: PureLogger (LoggerNameBox m) a

Instances

MonadTrans NamedPureLogger

Methods

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

Monad m => Monad (NamedPureLogger m)

Methods

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

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

return :: a -> NamedPureLogger m a

fail :: String -> NamedPureLogger m a

Functor m => Functor (NamedPureLogger m)

Methods

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

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

Monad m => Applicative (NamedPureLogger m)

Methods

pure :: a -> NamedPureLogger m a

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

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

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

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

MonadThrow m => MonadThrow (NamedPureLogger m)

Methods

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

Monad m => HasLoggerName (NamedPureLogger m)

Methods

askLoggerName :: NamedPureLogger m LoggerName

modifyLoggerName :: (LoggerName -> LoggerName) -> NamedPureLogger m a -> NamedPureLogger m a

Monad m => CanLog (NamedPureLogger m)

Methods

dispatchMessage :: LoggerName -> Severity -> Text -> NamedPureLogger m ()

MFunctor * NamedPureLogger

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b

Monad m => MonadState (Seq LogEvent) (NamedPureLogger m)

Methods

get :: NamedPureLogger m (Seq LogEvent)

put :: Seq LogEvent -> NamedPureLogger m ()

state :: (Seq LogEvent -> (a, Seq LogEvent)) -> NamedPureLogger m a

runNamedPureLog :: (Monad m, HasLoggerName m) => NamedPureLogger m a -> m (a, [LogEvent])

Return log of pure logging action as list of LogEvent, using logger name provided by context.

launchNamedPureLog :: (WithLogger n, Monad m) => (forall f. Functor f => m (f a) -> n (f b)) -> NamedPureLogger m a -> n b

Similar to launchPureLog, but provides logger name from current context.

Running the NamedPureLogger gives us the pair of target and the list of LogEvents, wrapped in Monad from where using the fact that (,) is Functor logging can be triggered.

Example

  newtype PureSmth a = ...
      deriving (MonadSmth, ...)

  instance MonadSmth m => MonadSmt (NamedLoggerName m)

  evalPureSmth :: PureSmth a -> a

  makeField    :: MonadSmth m => Data -> m Field

  run :: (MonadIO m, WithLogger m) => m ()
  run = do
      data  <- getData
      -- field :: Field
      field <- launchNamedPureLog (pure . evalPureSmth) (makeField data)
      --       ^ logging happens here
      ...

launchNamedPureLogWith :: (WithLogger n, Monad m) => (forall f. Functor f => m (f a) -> f b) -> NamedPureLogger m a -> n b

Similar to launchNamedPureLog, but calls pure on passed function result.

Example

The example from launchNamedPureLog with usage of this function will look like:

  newtype PureSmth a = ...
      deriving (MonadSmth, ...)

  instance MonadSmth m => MonadSmt (NamedLoggerName m)

  evalPureSmth :: PureSmth a -> a

  makeField    :: MonadSmth m => Data -> m Field

  run :: (MonadIO m, WithLogger m) => m ()
  run = do
      data  <- getData
      -- field :: Field
      field <- launchNamedPureLogWith evalPureSmth $ makeField data
      --       ^ logging happens here
      ...

usingNamedPureLogger :: Functor m => LoggerName -> NamedPureLogger m a -> m (a, [LogEvent])

Similar to runNamedPureLog, but using provided logger name.

logPureAction :: WithLogger m => NamedPureLogger m a -> m a

Perform pure-logging computation, log its events and return the result of the computation