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


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

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

-- | This function initializes global logging system for terminal output.
--   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).
--   
--   NOTE: you probably don't want to use this function. Consider
--   <a>setupLogging</a>.
--   
--   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.
initTerminalLogging :: MonadIO m => Bool -> Maybe 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 ()


-- | Logger configuration.
module System.Wlog.LoggerConfig
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

-- | Useful lens combinator to be used for logging initialization.
fromScratch :: Monoid m => State m a -> m

-- | Checks if logger rotation parameters are valid.
isValidRotation :: RotationParameters -> Bool

-- | 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)
ltFile :: Lens' LoggerTree (Maybe FilePath)
ltSeverity :: Lens' LoggerTree (Maybe Severity)
ltSubloggers :: Lens' LoggerTree LoggerMap

-- | Logger configuration which keeps <a>RotationParameters</a> and
--   <a>LoggerTree</a>.
data LoggerConfig
LoggerConfig :: Maybe RotationParameters -> Maybe Severity -> Any -> Any -> Endo LoggerName -> Maybe FilePath -> LoggerTree -> LoggerConfig

-- | Rotation parameters for logger config. See <a>Roller</a>.
[_lcRotation] :: LoggerConfig -> Maybe RotationParameters

-- | Severity for terminal output. If <tt>Nothing</tt> then
--   <tt>Warning</tt> is used.
[_lcTermSeverity] :: LoggerConfig -> Maybe Severity

-- | Show time for non-error messages. Note that error messages always have
--   timestamp.
[_lcShowTime] :: LoggerConfig -> Any

-- | <tt>True</tt> if we should also print output into console.
[_lcConsoleOutput] :: LoggerConfig -> Any

-- | Defines how to transform logger names in config.
[_lcMapper] :: LoggerConfig -> Endo LoggerName

-- | Path prefix to add for each logger file
[_lcFilePrefix] :: LoggerConfig -> Maybe FilePath

-- | Hierarchical tree of loggers.
[_lcTree] :: LoggerConfig -> LoggerTree
lcConsoleOutput :: Lens' LoggerConfig Any
lcFilePrefix :: Lens' LoggerConfig (Maybe FilePath)
lcMapper :: Lens' LoggerConfig (Endo LoggerName)
lcRotation :: Lens' LoggerConfig (Maybe RotationParameters)
lcShowTime :: Lens' LoggerConfig Any
lcTermSeverity :: Lens' LoggerConfig (Maybe Severity)
lcTree :: Lens' LoggerConfig LoggerTree

-- | Zooming into logger name with putting specific key.
zoomLogger :: Text -> State LoggerTree () -> State LoggerTree ()

-- | Setup <a>lcConsoleOutput</a> inside <a>LoggerConfig</a>.
consoleOutB :: Bool -> LoggerConfig

-- | Setup <a>lcMapper</a> inside <a>LoggerConfig</a>.
mapperB :: (LoggerName -> LoggerName) -> LoggerConfig

-- | Setup <a>lcFilePrefix</a> inside <a>LoggerConfig</a>.
prefixB :: FilePath -> LoggerConfig

-- | Adds sensible predefined set of parameters to logger.
productionB :: LoggerConfig

-- | Setup <a>lcShowTime</a> inside <a>LoggerConfig</a>.
showTimeB :: Bool -> LoggerConfig
instance GHC.Base.Monoid System.Wlog.LoggerConfig.LoggerConfig
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.LoggerConfig.LoggerConfig
instance Data.Aeson.Types.ToJSON.ToJSON System.Wlog.LoggerConfig.LoggerConfig
instance GHC.Show.Show System.Wlog.LoggerConfig.RotationParameters
instance GHC.Generics.Generic System.Wlog.LoggerConfig.RotationParameters
instance GHC.Base.Monoid System.Wlog.LoggerConfig.LoggerTree
instance Data.Aeson.Types.ToJSON.ToJSON 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 GHC.Show.Show System.Wlog.LoggerConfig.LoggerTree
instance GHC.Generics.Generic System.Wlog.LoggerConfig.LoggerTree


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

-- | Applies given builder to parsed logger config and initializes logging.
buildAndSetupYamlLogging :: MonadIO m => LoggerConfig -> FilePath -> m ()

-- | Initialize logger hierarchy from configuration file. See this module
--   description.
initLoggingFromYaml :: MonadIO m => 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. See <a>LoggerConfig</a> for more details.
setupLogging :: MonadIO m => LoggerConfig -> 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 Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (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