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


-- | 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 (GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m, GHC.Base.Monoid w) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monad m, System.Wlog.LoggerNameBox.HasLoggerName m, GHC.Base.Monoid w) => System.Wlog.LoggerNameBox.HasLoggerName (Control.Monad.Trans.RWS.Strict.RWST r w s 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)


-- | Some helpers and utilites to work with files
module System.Wlog.FileUtils

-- | Performs given action on file if file exists.
whenExist :: MonadIO m => FilePath -> (FilePath -> m ()) -> 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

-- | Logger configuration which keeps <a>RotationParameters</a> and
--   <a>LoggerTree</a>.
data LoggerConfig
LoggerConfig :: !(Maybe RotationParameters) -> !LoggerTree -> LoggerConfig
[lcRotation] :: LoggerConfig -> !(Maybe RotationParameters)
[lcTree] :: LoggerConfig -> !LoggerTree

-- | Stores configuration for hierarchical loggers.
data LoggerTree
LoggerTree :: !LoggerMap -> !(Maybe FilePath) -> !(Maybe Severity) -> LoggerTree
[ltSubloggers] :: LoggerTree -> !LoggerMap
[ltFile] :: LoggerTree -> !(Maybe FilePath)
[ltSeverity] :: LoggerTree -> !(Maybe Severity)
type LoggerMap = HashMap Text LoggerTree

-- | Parameters for logging rotation.
data RotationParameters
RotationParameters :: !Word64 -> !Word -> RotationParameters

-- | max size of file in bytes
[rpLogLimit] :: RotationParameters -> !Word64

-- | number of files to keep
[rpKeepFiles] :: RotationParameters -> !Word
isValidRotation :: RotationParameters -> Bool
instance GHC.Show.Show System.Wlog.LoggerConfig.LoggerConfig
instance GHC.Generics.Generic System.Wlog.LoggerConfig.LoggerConfig
instance GHC.Show.Show System.Wlog.LoggerConfig.RotationParameters
instance GHC.Generics.Generic System.Wlog.LoggerConfig.RotationParameters
instance GHC.Show.Show System.Wlog.LoggerConfig.LoggerTree
instance GHC.Generics.Generic System.Wlog.LoggerConfig.LoggerTree
instance Data.Aeson.Types.ToJSON.ToJSON System.Wlog.LoggerConfig.LoggerTree
instance Data.Default.Class.Default System.Wlog.LoggerConfig.LoggerTree
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.LoggerConfig.LoggerTree
instance Data.Text.Buildable.Buildable System.Wlog.LoggerConfig.RotationParameters
instance Data.Aeson.Types.ToJSON.ToJSON System.Wlog.LoggerConfig.RotationParameters
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.LoggerConfig.RotationParameters
instance Data.Default.Class.Default System.Wlog.LoggerConfig.LoggerConfig
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.LoggerConfig.LoggerConfig
instance Data.Aeson.Types.ToJSON.ToJSON System.Wlog.LoggerConfig.LoggerConfig


-- | Custom implementation of <a>LogHandler</a> with log rotation support.
module System.Wlog.Roller
data InvalidRotation
InvalidRotation :: !Text -> InvalidRotation

-- | Similar to <a>GenericHandler</a>. But holds file <a>Handle</a> inside
--   mutable variable (<a>MVar</a>) to be able to rotate loggers.
data RollerHandler
RollerHandler :: Priority -> LogFormatter RollerHandler -> MVar Handle -> (Handle -> String -> IO ()) -> (Handle -> IO ()) -> RollerHandler
[rhPriority] :: RollerHandler -> Priority
[rhFormatter] :: RollerHandler -> LogFormatter RollerHandler
[rhFileHandle] :: RollerHandler -> MVar Handle
[rhWriteAction] :: RollerHandler -> Handle -> String -> IO ()
[rhCloseAction] :: RollerHandler -> Handle -> IO ()
logIndex :: FilePath -> Int -> FilePath

-- | Create rotation logging handler.
rotationFileHandler :: MonadIO m => RotationParameters -> FilePath -> Priority -> m RollerHandler
instance GHC.Classes.Eq System.Wlog.Roller.InvalidRotation
instance GHC.Show.Show System.Wlog.Roller.InvalidRotation
instance System.Log.Handler.LogHandler System.Wlog.Roller.RollerHandler
instance GHC.Exception.Exception System.Wlog.Roller.InvalidRotation


-- | Parser for configuring and initializing logger from YAML file. Logger
--   configuration should look like this:
--   
--   <pre>
--   rotation:                # [optional] parameters for logging rotation
--       logLimit: 1024       # max size of log file in bytes
--       keepFiles: 3         # number of files with logs to keep including current one
--   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.Launcher
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. Create logging rotation if appropriate arguments
--   are passed.
traverseLoggerConfig :: MonadIO m => (LoggerName -> LoggerName) -> Maybe RotationParameters -> LoggerTree -> 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 logger 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.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (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)
instance System.Wlog.CanLog.CanLog m => System.Wlog.CanLog.CanLog (Control.Monad.Trans.Except.ExceptT s m)
instance (System.Wlog.CanLog.CanLog m, GHC.Base.Monoid w) => System.Wlog.CanLog.CanLog (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (System.Wlog.CanLog.CanLog m, GHC.Base.Monoid w) => System.Wlog.CanLog.CanLog (Control.Monad.Trans.RWS.Strict.RWST r w 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