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


-- | Simplified logging in IO for application writers.
--   
--   <tt>logging</tt> is a wrapper around <tt>monad-logger</tt> and
--   <tt>fast-logger</tt> which makes it easy to log from any
--   <a>MonadLogger</a> environment, or from <a>IO</a>. It provides the
--   following conveniences on top of those libraries:
--   
--   <ul>
--   <li>A <a>MonadLogger</a> instance for <a>IO</a>. Usually this is bad
--   for libraries, but can be very convenient for application writers who
--   know they always want to log from IO to the console. If you need to
--   log to other sources, or to make logging compile-time optional, use
--   <tt>monad-logger</tt> directly.</li>
--   <li>A set of shorter functions to type: <a>debug</a>, <a>log</a>,
--   <a>warn</a>, plus others that flush after each message, or which allow
--   providing a message source string.</li>
--   <li>Logging variants of <a>error</a>, <a>trace</a> and
--   <a>traceShow</a>, called <a>errorL</a>, <a>traceL</a> and
--   <a>traceShowL</a>. These use <a>unsafePerformIO</a> in order to act as
--   direct replacements, so the usual caveats apply.</li>
--   <li>A global function, <a>setDebugLevel</a>, which uses a global
--   <a>IORef</a> to record the logging level, saving you from having to
--   carry around the notion of <a>verbosity level</a> in a Reader
--   environment.</li>
--   <li>A set of <a>timed</a> variants, <a>timedLog</a> and
--   <a>timedDebug</a>, which report how long the specified action took to
--   execute in wall-clock time.</li>
--   </ul>
@package logging
@version 2.1.0


-- | Quick example of how to use this module:
--   
--   <pre>
--   import Control.Logging
--   
--   main = withStdoutLogging $ do
--        log <a>This is a log message!</a>
--        timedLog <a>This is a timed log message!</a> $ threadDelay 100000
--   </pre>
module Control.Logging

-- | Synonym for <a>logInfoN</a>. This module provides a <a>MonadLogger</a>
--   instance for IO, so this function can be used directly in IO. The only
--   requirement is that you must surround the body of your <tt>main</tt>
--   function with a call to <a>withStdoutLogging</a> or
--   <a>withStderrLogging</a>, to ensure that all logging buffers are
--   properly flushed on exit.
log :: MonadLogger m => Text -> m ()

-- | The apostrophe varients of the logging functions flush the log after
--   each message.
log' :: (MonadLogger m, MonadIO m) => Text -> m ()
logS :: MonadLogger m => Text -> Text -> m ()
logS' :: (MonadLogger m, MonadIO m) => Text -> Text -> m ()
warn :: MonadLogger m => Text -> m ()
warn' :: (MonadLogger m, MonadIO m) => Text -> m ()
warnS :: MonadLogger m => Text -> Text -> m ()
warnS' :: (MonadLogger m, MonadIO m) => Text -> Text -> m ()
debug :: MonadLogger m => Text -> m ()
debug' :: (MonadLogger m, MonadIO m) => Text -> m ()
debugS :: MonadLogger m => Text -> Text -> m ()
debugS' :: (MonadLogger m, MonadIO m) => Text -> Text -> m ()

-- | A logging variant of <a>error</a> which uses <a>unsafePerformIO</a> to
--   output a log message before calling <a>error</a>.
errorL :: Text -> a
errorL' :: Text -> a
errorSL :: Text -> Text -> a
errorSL' :: Text -> Text -> a
traceL :: Text -> a -> a
traceL' :: Text -> a -> a
traceSL :: Text -> Text -> a -> a
traceSL' :: Text -> Text -> a -> a
traceShowL :: Show a => a -> a1 -> a1
traceShowL' :: Show a => a -> a1 -> a1
traceShowSL :: Show a => Text -> a -> a1 -> a1
traceShowSL' :: Show a => Text -> a -> a1 -> a1

-- | Output a logging message both before an action begins, and after it
--   ends, reporting the total length of time. If an exception occurred, it
--   is also reported.
timedLog :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedLog' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedLogS :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a
timedLogS' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a

-- | Like <a>timedLog</a>, except that it does only logs when the action
--   has completed or failed after it is done.
timedLogEnd :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedLogEnd' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedLogEndS :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a
timedLogEndS' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a

-- | A debug variant of <a>timedLog</a>.
timedDebug :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedDebug' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedDebugS :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a
timedDebugS' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a
timedDebugEnd :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedDebugEnd' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> m a -> m a
timedDebugEndS :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a
timedDebugEndS' :: (MonadLogger m, MonadBaseControl IO m, MonadIO m) => Text -> Text -> m a -> m a

-- | This function, or <a>withStderrLogging</a>, must be wrapped around
--   whatever region of your application intends to use logging. Typically
--   it would be wrapped around the body of <tt>main</tt>.
withStdoutLogging :: (MonadBaseControl IO m, MonadIO m) => m a -> m a
withStdoutLoggingUsing :: (MonadBaseControl IO m, MonadIO m) => LoggingLogger -> m a -> m a
withStderrLogging :: (MonadBaseControl IO m, MonadIO m) => m a -> m a
withStderrLoggingUsing :: (MonadBaseControl IO m, MonadIO m) => LoggingLogger -> m a -> m a
withFileLogging :: (MonadBaseControl IO m, MonadIO m) => FilePath -> m a -> m a
withFileLoggingUsing :: (MonadBaseControl IO m, MonadIO m) => LoggingLogger -> FilePath -> m a -> m a

-- | Flush all collected logging messages. This is automatically called by
--   <a>withStdoutLogging</a> and <a>withStderrLogging</a> when those
--   blocks are exited by whatever means.
flushLog :: MonadIO m => m ()
data LoggingLogger

-- | This function is used to implement <a>monadLoggerLog</a> for the IO
--   instance. You may reuse it if you wish, or it can be passed as an
--   argument to <a>runLoggingT</a> -- in which case you must remember to
--   call <a>flushLog</a> before the program exits.
loggingLogger :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> IO ()

-- | Set the verbosity level. Messages at our higher than this level are
--   displayed. It defaults to <a>LevelDebug</a>.
setLogLevel :: LogLevel -> IO ()

-- | Set the format used for log timestamps.
setLogTimeFormat :: String -> IO ()
setDebugSourceRegex :: String -> IO ()
instance MonadLogger IO