-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Flexible, configurable, monadic and pretty logging
--   
--   This package contains nice wrapper around hslogger library.
@package log-warper
@version 0.2.2


-- | Custom wrapper around <tt>hslogger.Priority</tt>.
module System.Wlog.Severity

-- | This type specifies which messages to print.
data Severity
Debug :: Severity
Info :: Severity
Notice :: Severity
Warning :: Severity
Error :: Severity

-- | Maps <a>Severity</a> into <a>Priority</a>.
convertSeverity :: Severity -> Priority
instance Data.SafeCopy.SafeCopy.SafeCopy System.Wlog.Severity.Severity
instance GHC.Classes.Eq System.Wlog.Severity.Severity
instance GHC.Read.Read System.Wlog.Severity.Severity
instance GHC.Show.Show System.Wlog.Severity.Severity
instance GHC.Generics.Generic System.Wlog.Severity.Severity
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.Severity.Severity
instance Data.Aeson.Types.ToJSON.ToJSON System.Wlog.Severity.Severity


-- | Contains <tt>newtype</tt> wrapper around logger name to support
--   hierarchy.
module System.Wlog.LoggerName

-- | Logger name to keep in context.
newtype LoggerName
LoggerName :: String -> LoggerName
[loggerName] :: LoggerName -> String

-- | <a>LoggerName</a> formatter which restricts type.
loggerNameF :: Format r (LoggerName -> r)
instance Data.SafeCopy.SafeCopy.SafeCopy System.Wlog.LoggerName.LoggerName
instance Data.Semigroup.Semigroup System.Wlog.LoggerName.LoggerName
instance GHC.Base.Monoid System.Wlog.LoggerName.LoggerName
instance Data.Text.Buildable.Buildable System.Wlog.LoggerName.LoggerName
instance Data.Hashable.Class.Hashable System.Wlog.LoggerName.LoggerName
instance GHC.Classes.Eq System.Wlog.LoggerName.LoggerName
instance Data.String.IsString System.Wlog.LoggerName.LoggerName
instance GHC.Show.Show System.Wlog.LoggerName.LoggerName


-- | This module contains type classes for loggers that have
--   <a>LoggerName</a>.
module System.Wlog.LoggerNameBox

-- | This type class exists to remove boilerplate logging by adding the
--   logger's name to the context in each module.
--   
--   TODO: replace current methods with Lens?
class HasLoggerName m

-- | Extract logger name from context
getLoggerName :: HasLoggerName m => m LoggerName

-- | Change logger name in context
modifyLoggerName :: HasLoggerName m => (LoggerName -> LoggerName) -> m a -> m a

-- | Default implementation of <tt>WithNamedLogger</tt>.
newtype LoggerNameBox m a
LoggerNameBox :: ReaderT LoggerName m a -> LoggerNameBox m a
[loggerNameBoxEntry] :: LoggerNameBox m a -> ReaderT LoggerName m a

-- | Set logger name in context.
setLoggerName :: HasLoggerName m => LoggerName -> m a -> m a

-- | Runs a <a>LoggerNameBox</a> with specified initial <a>LoggerName</a>.
usingLoggerName :: LoggerName -> LoggerNameBox m a -> m a
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.Trans.Class.MonadTrans System.Wlog.LoggerNameBox.LoggerNameBox
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance GHC.Base.Monad m => GHC.Base.Monad (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance GHC.Base.Functor m => GHC.Base.Functor (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance (GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.Reader.ReaderT a m)
instance (GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.State.Lazy.StateT a m)
instance (GHC.Base.Monoid w, GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.Except.ExceptT e m)
instance (GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.Cont.ContT r m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance GHC.Base.Monad m => System.Wlog.LoggerNameBox.HasLoggerName (System.Wlog.LoggerNameBox.LoggerNameBox m)


-- | Logging functionality. This module is wrapper over <a>hslogger</a>,
--   which allows to keep logger name in monadic context.
module System.Wlog.Wrapper

-- | Options determining formatting of messages.
data LoggingFormat
LoggingFormat :: !Bool -> LoggingFormat

-- | Show time for non-error messages. Note that error messages always have
--   timestamp.
[lfShowTime] :: LoggingFormat -> !Bool

-- | This type specifies which messages to print.
data Severity
Debug :: Severity
Info :: Severity
Notice :: Severity
Warning :: Severity
Error :: Severity

-- | Maps <a>Severity</a> into <a>Priority</a>.
convertSeverity :: Severity -> Priority

-- | Version of initLoggingWith without any predefined loggers.
initLogging :: MonadIO m => Severity -> m ()

-- | This function initializes global logging system. At high level, it
--   sets severity which will be used by all loggers by default, sets
--   default formatters and sets custom severity for given loggers (if
--   any).
--   
--   On a lower level it does the following: 1. Removes default handler
--   from root logger, sets two handlers such that: 1.1. All messages are
--   printed to <i>stdout</i>. 1.2. Moreover messages with at least
--   <a>Error</a> severity are printed to <i>stderr</i>. 2. Sets given
--   Severity to root logger, so that it will be used by descendant loggers
--   by default. 3. Applies <a>setSeverity</a> to given loggers. It can be
--   done later using <a>setSeverity</a> directly.
initLoggingWith :: MonadIO m => LoggingFormat -> Severity -> m ()

-- | Lifted alias to <a>removeAllHandlers</a>.
releaseAllHandlers :: MonadIO m => m ()

-- | Set severity for given logger. By default parent's severity is used.
setSeverity :: MonadIO m => LoggerName -> Severity -> m ()

-- | Set or clear severity.
setSeverityMaybe :: MonadIO m => LoggerName -> Maybe Severity -> m ()
instance GHC.Show.Show System.Wlog.Wrapper.LoggingFormat
instance Data.Default.Class.Default System.Wlog.Wrapper.LoggingFormat


-- | Logger configuration.
module System.Wlog.LoggerConfig
data LoggerConfig
LoggerConfig :: !LoggerMap -> !(Maybe FilePath) -> !(Maybe Severity) -> LoggerConfig
[lcSubloggers] :: LoggerConfig -> !LoggerMap
[lcFile] :: LoggerConfig -> !(Maybe FilePath)
[lcSeverity] :: LoggerConfig -> !(Maybe Severity)
type LoggerMap = HashMap Text LoggerConfig
instance GHC.Show.Show System.Wlog.LoggerConfig.LoggerConfig
instance GHC.Generics.Generic System.Wlog.LoggerConfig.LoggerConfig
instance Data.Aeson.Types.ToJSON.ToJSON System.Wlog.LoggerConfig.LoggerConfig
instance Data.Default.Class.Default System.Wlog.LoggerConfig.LoggerConfig
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.LoggerConfig.LoggerConfig


-- | Parser for configuring and initializing logger from YAML file. Logger
--   configuration should look like this:
--   
--   <pre>
--   node:                    # logger named «node»
--       severity: Warning    # severity for logger «node»
--       comm:                # logger named «node.comm»
--           severity: Info   # severity for logger «node.comm»
--           file: patak.jpg  # messages will be also printed to patak.jpg
--   </pre>
--   
--   And this configuration corresponds two loggers with
--   <tt>LoggerName'</tt>s <tt>node</tt> and <tt>node.comm</tt>.
module System.Wlog.Parser
initLoggingFromYaml :: MonadIO m => FilePath -> Maybe FilePath -> m ()

-- | Initialize logger hierarchy from configuration file. See this module
--   description.
initLoggingFromYamlWithMapper :: MonadIO m => (LoggerName -> LoggerName) -> FilePath -> Maybe FilePath -> m ()

-- | Parses logger config from given file path.
parseLoggerConfig :: MonadIO m => FilePath -> m LoggerConfig

-- | This function traverses <a>LoggerConfig</a> initializing all
--   subloggers with <a>Severity</a> and redirecting output in file
--   handlers. Also takes <a>FilePath</a> prefix to create directory for
--   file handlers output.
traverseLoggerConfig :: MonadIO m => (LoggerName -> LoggerName) -> LoggerConfig -> Maybe FilePath -> m ()


-- | Type class that add ability to log messages. Supports pure and IO
--   logging.
module System.Wlog.CanLog

-- | Instances of this class should explain how they add messages to their
--   log.
class Monad m => CanLog m where dispatchMessage name sev t = lift $ dispatchMessage name sev t
dispatchMessage :: CanLog m => LoggerName -> Severity -> Text -> m ()
dispatchMessage :: (CanLog m, MonadTrans t, t n ~ m, CanLog n) => LoggerName -> Severity -> Text -> t n ()

-- | Type alias for constraints <a>CanLog</a> and <a>HasLoggerName</a>. We
--   need two different type classes to support more flexible interface but
--   in practice we usually use them both.
type WithLogger m = (CanLog m, HasLoggerName m)

-- | Pure implementation of <a>CanLog</a> type class. Instead of writing
--   log messages into console it appends log messages into <a>WriterT</a>
--   log. It uses <a>DList</a> for better performance, because messages can
--   be added only at the end of log. But it uses <tt>unsafePerformIO</tt>
--   so use with caution within IO.
--   
--   TODO: Should we use some <tt>Data.Tree</tt>-like structure to observe
--   message only by chosen loger names?
newtype PureLogger m a
PureLogger :: WriterT (DList LogEvent) m a -> PureLogger m a
[runPureLogger] :: PureLogger m a -> WriterT (DList LogEvent) m a

-- | Holds all required information for <tt>dispatchLoggerName</tt>
--   function.
data LogEvent
LogEvent :: !LoggerName -> !Severity -> !Text -> LogEvent
[leLoggerName] :: LogEvent -> !LoggerName
[leSeverity] :: LogEvent -> !Severity
[leMessage] :: LogEvent -> !Text

-- | Logs all <tt>LogEvent'</tt>s from given list. This function supposed
--   to be used after <a>runPureLog</a>.
dispatchEvents :: WithLogger m => [LogEvent] -> m ()

-- | Return log of pure logging action as list of <a>LogEvent</a>.
runPureLog :: Monad m => PureLogger m a -> m (a, [LogEvent])

-- | Shortcut for <a>logMessage</a> to use according severity.
logDebug :: WithLogger m => Text -> m ()

-- | Shortcut for <a>logMessage</a> to use according severity.
logError :: WithLogger m => Text -> m ()

-- | Shortcut for <a>logMessage</a> to use according severity.
logInfo :: WithLogger m => Text -> m ()

-- | Shortcut for <a>logMessage</a> to use according severity.
logNotice :: WithLogger m => Text -> m ()

-- | Shortcut for <a>logMessage</a> to use according severity.
logWarning :: WithLogger m => Text -> m ()

-- | Logs message with specified severity using logger name in context.
logMessage :: WithLogger m => Severity -> Text -> m ()
instance (System.Wlog.LoggerNameBox.HasLoggerName m, GHC.Base.Monad m) => System.Wlog.LoggerNameBox.HasLoggerName (System.Wlog.CanLog.PureLogger m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (System.Wlog.CanLog.PureLogger m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (System.Wlog.CanLog.PureLogger m)
instance GHC.Base.Monad m => Control.Monad.Writer.Class.MonadWriter (Data.DList.DList System.Wlog.CanLog.LogEvent) (System.Wlog.CanLog.PureLogger m)
instance Control.Monad.Trans.Class.MonadTrans System.Wlog.CanLog.PureLogger
instance GHC.Base.Monad m => GHC.Base.Monad (System.Wlog.CanLog.PureLogger m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (System.Wlog.CanLog.PureLogger m)
instance GHC.Base.Functor m => GHC.Base.Functor (System.Wlog.CanLog.PureLogger m)
instance Data.SafeCopy.SafeCopy.SafeCopy System.Wlog.CanLog.LogEvent
instance GHC.Base.Monad m => System.Wlog.CanLog.CanLog (System.Wlog.CanLog.PureLogger m)
instance GHC.Show.Show System.Wlog.CanLog.LogEvent
instance System.Wlog.CanLog.CanLog GHC.Types.IO
instance System.Wlog.CanLog.CanLog m => System.Wlog.CanLog.CanLog (System.Wlog.LoggerNameBox.LoggerNameBox m)
instance System.Wlog.CanLog.CanLog m => System.Wlog.CanLog.CanLog (Control.Monad.Trans.Reader.ReaderT r m)
instance System.Wlog.CanLog.CanLog m => System.Wlog.CanLog.CanLog (Control.Monad.Trans.State.Lazy.StateT s m)


-- | Logging functionality. This module is wrapper over <a>hslogger</a>,
--   which allows to keep logger name in monadic context. Messages are
--   colored depending on used serverity.
module System.Wlog