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


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


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

-- | Severity is level of log message importance. It uniquely determines
--   which messages to print.
data Severity

-- | Debug messages
Debug :: Severity

-- | Information
Info :: Severity

-- | Important (more than average) information
Notice :: Severity

-- | General warnings
Warning :: Severity

-- | General errors/severe errors
Error :: Severity

-- | Internal type of log records.
type LogRecord = (Severity, Text)
instance Data.SafeCopy.SafeCopy.SafeCopy System.Wlog.Severity.Severity
instance GHC.Generics.Generic System.Wlog.Severity.Severity
instance GHC.Read.Read System.Wlog.Severity.Severity
instance GHC.Show.Show System.Wlog.Severity.Severity
instance GHC.Enum.Bounded System.Wlog.Severity.Severity
instance GHC.Enum.Enum System.Wlog.Severity.Severity
instance GHC.Classes.Ord System.Wlog.Severity.Severity
instance GHC.Classes.Eq 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.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (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.Strict.StateT 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 System.Wlog.LoggerNameBox.HasLoggerName Data.Functor.Identity.Identity
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 Control.Monad.Morph.MFunctor System.Wlog.LoggerNameBox.LoggerNameBox
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 ()


-- | Pretty looking formatters for logger.
--   
--   Please see <a>System.WLog.Logger</a> for extensive documentation on
--   the logging system.
module System.Wlog.Formatter
formatLogMessage :: LoggerName -> Severity -> UTCTime -> Text -> Text

-- | Same as <a>formatLogMessage</a>, but with colorful output
formatLogMessageColors :: LoggerName -> Severity -> UTCTime -> Text -> Text
stdoutFormatter :: Bool -> Bool -> LogFormatter a
stderrFormatter :: Bool -> LogFormatter a
stdoutFormatterTimeRounded :: Int -> LogFormatter a
getRoundedTime :: Int -> IO UTCTime

-- | A LogFormatter is used to format log messages. Note that it is
--   paramterized on the <tt>Handler</tt> to allow the formatter to use
--   information specific to the handler (an example of can be seen in the
--   formatter used in <a>Syslog</a>)
type LogFormatter a = a  The LogHandler that the passed message came from -> LogRecord  The log message and priority -> String  The logger name -> IO Text  The formatted log message

-- | Returns the passed message as is, ie. no formatting is done.
nullFormatter :: LogFormatter a

-- | Takes a format string, and returns a formatter that may be used to
--   format log messages. The format string may contain variables prefixed
--   with a $-sign which will be replaced at runtime with corresponding
--   values. The currently supported variables are:
--   
--   <ul>
--   <li><tt>$msg</tt> - The actual log message</li>
--   <li><tt>$loggername</tt> - The name of the logger</li>
--   <li><tt>$prio</tt> - The priority level of the message</li>
--   <li><tt>$tid</tt> - The thread ID</li>
--   <li><tt>$pid</tt> - Process ID (Not available on windows)</li>
--   <li><tt>$time</tt> - The current time</li>
--   <li><tt>$utcTime</tt> - The current time in UTC Time</li>
--   </ul>
simpleLogFormatter :: String -> LogFormatter a

-- | Like <a>simpleLogFormatter</a> but allow the time format to be
--   specified in the first parameter (this is passed to <a>formatTime</a>)
tfLogFormatter :: String -> String -> LogFormatter a

-- | An extensible formatter that allows new substition <i>variables</i> to
--   be defined. Each variable has an associated IO action that is used to
--   produce the string to substitute for the variable name. The predefined
--   variables are the same as for <a>simpleLogFormatter</a>
--   <i>excluding</i> <tt>$time</tt> and <tt>$utcTime</tt>.
varFormatter :: [(String, IO Text)] -> String -> LogFormatter a


-- | Definition of log handler support
--   
--   For some handlers, check out <a>System.WLog.Handler.Simple</a> and
--   <a>System.WLog.Handler.Syslog</a>.
--   
--   Please see <a>System.WLog.Logger</a> for extensive documentation on
--   the logging system.
--   
--   Written by John Goerzen, jgoerzen@complete.org
module System.Wlog.Handler

-- | Tag identifying handlers.
data LogHandlerTag
HandlerFilelike :: FilePath -> LogHandlerTag
HandlerOther :: String -> LogHandlerTag

-- | This is the base class for the various log handlers. They should all
--   adhere to this class.
class LogHandler a where getFormatter _h = nullFormatter handle h (pri, msg) logname = when (pri >= (getLevel h)) $ do { formattedMsg <- (getFormatter h) h (pri, msg) logname; emit h (pri, formattedMsg) logname }

-- | Tag of handler. Is arbitrary. Made for identification.
getTag :: LogHandler a => a -> LogHandlerTag

-- | Sets the log level. <a>handle</a> will drop items beneath this level.
setLevel :: LogHandler a => a -> Severity -> a

-- | Gets the current level.
getLevel :: LogHandler a => a -> Severity

-- | Set a log formatter to customize the log format for this Handler
setFormatter :: LogHandler a => a -> LogFormatter a -> a
getFormatter :: LogHandler a => a -> LogFormatter a

-- | Logs an event if it meets the requirements given by the most recent
--   call to <a>setLevel</a>.
handle :: LogHandler a => a -> LogRecord -> String -> IO ()

-- | Forces an event to be logged regardless of the configured level.
emit :: LogHandler a => a -> LogRecord -> String -> IO ()

-- | Read back from logger (e.g. file), newest first. You specify the
--   number of (newest) logging entries. Logger can return <tt>pure []</tt>
--   if this behaviour can't be emulated or store buffer.
readBack :: LogHandler a => a -> Int -> IO [Text]

-- | Closes the logging system, causing it to close any open files, etc.
close :: LogHandler a => a -> IO ()
instance GHC.Classes.Eq System.Wlog.Handler.LogHandlerTag
instance GHC.Show.Show System.Wlog.Handler.LogHandlerTag


-- | Simple log handlers
--   
--   Written by John Goerzen, jgoerzen@complete.org
module System.Wlog.Handler.Simple

-- | Create a stream log handler. Log messages sent to this handler will be
--   sent to the stream used initially. Note that the <a>close</a> method
--   will have no effect on stream handlers; it does not actually close the
--   underlying stream.
streamHandler :: Handle -> Severity -> IO (GenericHandler Handle)

-- | Create a file log handler. Log messages sent to this handler will be
--   sent to the filename specified, which will be opened in Append mode.
--   Calling <a>close</a> on the handler will close the file.
fileHandler :: FilePath -> Severity -> IO (GenericHandler Handle)

-- | A helper data type.
data GenericHandler a
GenericHandler :: !Severity -> !(LogFormatter (GenericHandler a)) -> !a -> !(a -> Text -> IO ()) -> !(a -> IO ()) -> !(MVar (MemoryQueue Text)) -> !LogHandlerTag -> GenericHandler a
[severity] :: GenericHandler a -> !Severity
[formatter] :: GenericHandler a -> !(LogFormatter (GenericHandler a))
[privData] :: GenericHandler a -> !a
[writeFunc] :: GenericHandler a -> !(a -> Text -> IO ())
[closeFunc] :: GenericHandler a -> !(a -> IO ())
[readBackBuffer] :: GenericHandler a -> !(MVar (MemoryQueue Text))
[ghTag] :: GenericHandler a -> !LogHandlerTag

-- | Like <a>streamHandler</a>, but note the priority and logger name along
--   with each message.
verboseStreamHandler :: Handle -> Severity -> IO (GenericHandler Handle)
instance Data.Typeable.Internal.Typeable a => System.Wlog.Handler.LogHandler (System.Wlog.Handler.Simple.GenericHandler a)


-- | Haskell Logging Framework, Primary Interface
--   
--   Written by John Goerzen, jgoerzen@complete.org
--   
--   This module is a modification of <a>System.Log.Logger</a> of
--   <tt>hslogger</tt> library. Unless proper description is written here,
--   please use the original documentation available on hackage/hslogger.
module System.Wlog.Logger
data Logger

-- | Severity is level of log message importance. It uniquely determines
--   which messages to print.
data Severity

-- | Debug messages
Debug :: Severity

-- | Information
Info :: Severity

-- | Important (more than average) information
Notice :: Severity

-- | General warnings
Warning :: Severity

-- | General errors/severe errors
Error :: Severity

-- | Log a message using the given logger at a given priority.
logM :: String -> Severity -> Text -> IO ()
logMCond :: String -> Severity -> Text -> (LogHandlerTag -> Bool) -> IO ()

-- | Log a message at <a>Debug</a> priority
debugM :: String -> Text -> IO ()

-- | Log a message at <a>Info</a> priority
infoM :: String -> Text -> IO ()

-- | Log a message at <a>Notice</a> priority
noticeM :: String -> Text -> IO ()

-- | Log a message at <a>Warning</a> priority
warningM :: String -> Text -> IO ()

-- | Log a message at <a>Error</a> priority
errorM :: String -> Text -> IO ()

-- | Allow graceful shutdown. Release all opened files<i>handlers</i>etc.
removeAllHandlers :: IO ()

-- | Traps exceptions that may occur, logging them, then passing them on.
--   
--   Takes a logger name, priority, leading description text (you can set
--   it to <tt>""</tt> if you don't want any), and action to run.
traplogging :: String -> Severity -> Text -> IO a -> IO a

-- | Log a message, assuming the current logger's level permits it.
logL :: Logger -> Severity -> Text -> IO ()

-- | Logs a message with condition.
logLCond :: Logger -> Severity -> Text -> (LogHandlerTag -> Bool) -> IO ()

-- | Returns the logger for the given name. If no logger with that name
--   exists, creates new loggers and any necessary parent loggers, with no
--   connected handlers.
getLogger :: String -> IO Logger

-- | Returns the root logger.
getRootLogger :: IO Logger

-- | The name of the root logger, which is always defined and present on
--   the system.
rootLoggerName :: String

-- | Add handler to <a>Logger</a>. Returns a new <a>Logger</a>.
addHandler :: LogHandler a => a -> Logger -> Logger

-- | Remove a handler from the <a>Logger</a>. Handlers are removed in the
--   reverse order they were added, so the following property holds for any
--   <a>LogHandler</a> <tt>h</tt>:
--   
--   <pre>
--   removeHandler . addHandler h = id
--   </pre>
--   
--   If no handlers are associated with the <a>Logger</a>, it is returned
--   unchanged.
--   
--   The root logger's default handler that writes every message to stderr
--   can be removed by using this function before any handlers have been
--   added to the root logger:
--   
--   <pre>
--   updateGlobalLogger rootLoggerName removeHandler
--   </pre>
removeHandler :: Logger -> Logger

-- | Set the 'Logger'\'s list of handlers to the list supplied. All
--   existing handlers are removed first.
setHandlers :: LogHandler a => [a] -> Logger -> Logger

-- | Returns the "level" of the logger. Items beneath this level will be
--   ignored.
getLevel :: Logger -> Maybe Severity

-- | Sets the "level" of the <a>Logger</a>. Returns a new <a>Logger</a>
--   object with the new level.
setLevel :: Severity -> Logger -> Logger

-- | Clears the "level" of the <a>Logger</a>. It will now inherit the level
--   of | its parent.
clearLevel :: Logger -> Logger

-- | Updates the global record for the given logger to take into account
--   any changes you may have made.
saveGlobalLogger :: Logger -> IO ()

-- | Helps you make changes on the given logger. Takes a function that
--   makes changes and writes those changes back to the global database.
--   Here's an example from above ("s" is a <a>LogHandler</a>):
--   
--   <pre>
--   updateGlobalLogger "MyApp.BuggyComponent"
--                      (setLevel DEBUG . setHandlers [s])
--   </pre>
updateGlobalLogger :: String -> (Logger -> Logger) -> IO ()

-- | Sets file prefix to <a>LogInternalState</a>.
setPrefix :: Maybe FilePath -> IO ()

-- | Retrieves content of log file(s) given path (w/o
--   <tt>_lcFilePrefix</tt>, as specified in your config). Example: there's
--   <tt>component.log</tt> in config, but this function will return
--   <tt>[component.log.122, component.log.123]</tt> if you want to.
--   Content is file lines newest first.
--   
--   FYI: this function is implemented to avoid the following problem:
--   log-warper holds open handles to files, so trying to open log file for
--   read would result in <tt>IOException</tt>.
retrieveLogContent :: (MonadIO m) => FilePath -> Maybe Int -> m [Text]
instance GHC.Generics.Generic System.Wlog.Logger.LogInternalState
instance GHC.Generics.Generic System.Wlog.Logger.Logger


-- | Syslog handler for the Haskell Logging Framework
--   
--   Written by John Goerzen, jgoerzen@complete.org
--   
--   This module implements an interface to the Syslog service commonly
--   found in Unix/Linux systems. This interface is primarily of interest
--   to developers of servers, as Syslog does not typically display
--   messages in an interactive fashion.
--   
--   This module is written in pure Haskell and is capable of logging to a
--   local or remote machine using the Syslog protocol.
--   
--   You can create a new Syslog <a>LogHandler</a> by calling
--   <a>openlog</a>.
--   
--   More information on the Haskell Logging Framework can be found at
--   <a>System.Log.Logger</a>. This module can also be used outside of the
--   rest of that framework for those interested in that.
module System.Wlog.Handler.Syslog
data SyslogHandler

-- | Initialize the Syslog system using the local system's default
--   interface, /dev/log. Will return a new <a>LogHandler</a>.
--   
--   On Windows, instead of using /dev/log, this will attempt to send UDP
--   messages to something listening on the syslog port (514) on localhost.
--   
--   Use <a>openlog_remote</a> if you need more control.
openlog :: String -> [Option] -> Facility -> Severity -> IO SyslogHandler

-- | Initialize the Syslog system using an arbitrary Unix socket (FIFO).
--   
--   Not supported under Windows.
openlog_local :: String -> String -> [Option] -> Facility -> Severity -> IO SyslogHandler

-- | Log to a remote server via UDP.
openlog_remote :: Family -> HostName -> PortNumber -> String -> [Option] -> Facility -> Severity -> IO SyslogHandler

-- | The most powerful initialization mechanism. Takes an open datagram
--   socket.
openlog_generic :: Socket -> SockAddr -> SocketType -> String -> [Option] -> Facility -> Severity -> IO SyslogHandler

-- | Facilities are used by the system to determine where messages are
--   sent.
data Facility

-- | Kernel messages; you should likely never use this in your programs
KERN :: Facility

-- | General userland messages. Use this if nothing else is appropriate
USER :: Facility

-- | E-Mail system
MAIL :: Facility

-- | Daemon (server process) messages
DAEMON :: Facility

-- | Authentication or security messages
AUTH :: Facility

-- | Internal syslog messages; you should likely never use this in your
--   programs
SYSLOG :: Facility

-- | Printer messages
LPR :: Facility

-- | Usenet news
NEWS :: Facility

-- | UUCP messages
UUCP :: Facility

-- | Cron messages
CRON :: Facility

-- | Private authentication messages
AUTHPRIV :: Facility

-- | FTP messages
FTP :: Facility

-- | LOCAL0 through LOCAL7 are reserved for you to customize as you wish
LOCAL0 :: Facility
LOCAL1 :: Facility
LOCAL2 :: Facility
LOCAL3 :: Facility
LOCAL4 :: Facility
LOCAL5 :: Facility
LOCAL6 :: Facility
LOCAL7 :: Facility

-- | Options for <a>openlog</a>.
data Option

-- | Automatically log process ID (PID) with each message
PID :: Option

-- | Send a copy of each message to stderr
PERROR :: Option
instance GHC.Read.Read System.Wlog.Handler.Syslog.Option
instance GHC.Show.Show System.Wlog.Handler.Syslog.Option
instance GHC.Classes.Eq System.Wlog.Handler.Syslog.Option
instance GHC.Read.Read System.Wlog.Handler.Syslog.Facility
instance GHC.Show.Show System.Wlog.Handler.Syslog.Facility
instance GHC.Classes.Eq System.Wlog.Handler.Syslog.Facility
instance System.Wlog.Handler.LogHandler System.Wlog.Handler.Syslog.SyslogHandler


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

-- | Severity is level of log message importance. It uniquely determines
--   which messages to print.
data Severity

-- | Debug messages
Debug :: Severity

-- | Information
Info :: Severity

-- | Important (more than average) information
Notice :: Severity

-- | General warnings
Warning :: Severity

-- | General errors/severe errors
Error :: Severity

-- | 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 -> 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. Usually
--   should be used with <a>zoomLogger</a>.
fromScratch :: Monoid m => State m a -> m

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

-- | Wrapper over file handler with additional rounding option.
data HandlerWrap
HandlerWrap :: !FilePath -> !(Maybe Int) -> HandlerWrap

-- | Path to the file to be handled.
[_hwFilePath] :: HandlerWrap -> !FilePath

-- | Amount of seconds to round time on (if set).
[_hwRounding] :: HandlerWrap -> !(Maybe Int)
hwFilePath :: Lens' HandlerWrap FilePath
hwRounding :: Lens' HandlerWrap (Maybe Int)

-- | Stores configuration for hierarchical loggers.
data LoggerTree
LoggerTree :: !LoggerMap -> ![HandlerWrap] -> !(Maybe Severity) -> LoggerTree
[_ltSubloggers] :: LoggerTree -> !LoggerMap
[_ltFiles] :: LoggerTree -> ![HandlerWrap]
[_ltSeverity] :: LoggerTree -> !(Maybe Severity)
ltFiles :: Lens' LoggerTree [HandlerWrap]
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 -> 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

-- | Show <tt>ThreadId</tt> for current logging thread.
[_lcShowTid] :: 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
lcShowTid :: 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 :: 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>lcShowTid</a> to <a>True</a> inside <a>LoggerConfig</a>.
showTidB :: LoggerConfig

-- | Setup <a>lcShowTime</a> to <a>True</a> inside <a>LoggerConfig</a>.
showTimeB :: 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.HandlerWrap
instance Data.Aeson.Types.FromJSON.FromJSON System.Wlog.LoggerConfig.HandlerWrap
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
instance GHC.Show.Show System.Wlog.LoggerConfig.HandlerWrap
instance GHC.Generics.Generic System.Wlog.LoggerConfig.HandlerWrap


-- | Custom implementation of <a>LogHandler</a> with log rotation support.
module System.Wlog.Handler.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 :: !Severity -> !(LogFormatter RollerHandler) -> !(MVar Handle) -> !(Handle -> Text -> IO ()) -> !(Handle -> IO ()) -> !FilePath -> RollerHandler
[rhSeverity] :: RollerHandler -> !Severity
[rhFormatter] :: RollerHandler -> !(LogFormatter RollerHandler)
[rhFileHandle] :: RollerHandler -> !(MVar Handle)
[rhWriteAction] :: RollerHandler -> !(Handle -> Text -> IO ())
[rhCloseAction] :: RollerHandler -> !(Handle -> IO ())
[rhFileName] :: RollerHandler -> !FilePath
logIndex :: FilePath -> Int -> FilePath

-- | Create rotation logging handler.
rotationFileHandler :: MonadIO m => RotationParameters -> FilePath -> Severity -> m RollerHandler
instance GHC.Classes.Eq System.Wlog.Handler.Roller.InvalidRotation
instance GHC.Show.Show System.Wlog.Handler.Roller.InvalidRotation
instance System.Wlog.Handler.LogHandler System.Wlog.Handler.Roller.RollerHandler
instance GHC.Exception.Exception System.Wlog.Handler.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 -> m ()

-- | 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 <tt>DList</tt> 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 :: CanLog m => [LogEvent] -> m ()

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

-- | Performs actual logging once given action completes.
launchPureLog :: (CanLog n, Monad m) => (forall f. Functor f => m (f a) -> n (f b)) -> PureLogger m a -> n b
newtype NamedPureLogger m a
NamedPureLogger :: PureLogger (LoggerNameBox m) a -> NamedPureLogger m a
[runNamedPureLogger] :: NamedPureLogger m a -> PureLogger (LoggerNameBox m) a

-- | Return log of pure logging action as list of <a>LogEvent</a>, using
--   logger name provided by context.
runNamedPureLog :: (Monad m, HasLoggerName m) => NamedPureLogger m a -> m (a, [LogEvent])

-- | Similar as <a>launchPureLog</a>, but provides logger name from current
--   context.
launchNamedPureLog :: (WithLogger n, Monad m) => (forall f. Functor f => m (f a) -> n (f b)) -> NamedPureLogger m a -> n b

-- | 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 GHC.Base.Monad m => System.Wlog.LoggerNameBox.HasLoggerName (System.Wlog.CanLog.NamedPureLogger m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (System.Wlog.CanLog.NamedPureLogger m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (System.Wlog.CanLog.NamedPureLogger m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (System.Wlog.CanLog.NamedPureLogger m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (System.Wlog.CanLog.NamedPureLogger m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (System.Wlog.CanLog.NamedPureLogger m)
instance GHC.Base.Monad m => Control.Monad.Writer.Class.MonadWriter (Data.DList.DList System.Wlog.CanLog.LogEvent) (System.Wlog.CanLog.NamedPureLogger m)
instance GHC.Base.Monad m => GHC.Base.Monad (System.Wlog.CanLog.NamedPureLogger m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (System.Wlog.CanLog.NamedPureLogger m)
instance GHC.Base.Functor m => GHC.Base.Functor (System.Wlog.CanLog.NamedPureLogger m)
instance (System.Wlog.LoggerNameBox.HasLoggerName m, GHC.Base.Monad m) => System.Wlog.LoggerNameBox.HasLoggerName (System.Wlog.CanLog.PureLogger m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (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 Control.Monad.Morph.MFunctor System.Wlog.CanLog.PureLogger
instance Control.Monad.Trans.Class.MonadTrans System.Wlog.CanLog.NamedPureLogger
instance GHC.Base.Monad m => System.Wlog.CanLog.CanLog (System.Wlog.CanLog.NamedPureLogger m)
instance Control.Monad.Morph.MFunctor System.Wlog.CanLog.NamedPureLogger
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.Strict.StateT s 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