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


-- | Simple log for Haskell
--   
--   Log library for Haskell with removing unnecessary traces
@package simple-log
@version 0.8.2

module System.Log.Simple.Base

-- | Level of message
data Level
Trace :: Level
Debug :: Level
Info :: Level
Warning :: Level
Error :: Level
Fatal :: Level

-- | Parse level
level :: Text -> Maybe Level

-- | Parse level, failing on invalid input
level_ :: Text -> Level

-- | Component — each one have separate log scopes and can have different
--   politics Child component's root politics inherits its parent root
--   politics Component name parts stored in reverse order
newtype Component
Component :: [Text] -> Component
[componentPath] :: Component -> [Text]

-- | Log scope, also stored in reverse order
newtype Scope
Scope :: [Text] -> Scope
[scopePath] :: Scope -> [Text]

-- | Log message
data Message
Message :: ZonedTime -> Level -> Component -> Scope -> Text -> Message
[messageTime] :: Message -> ZonedTime
[messageLevel] :: Message -> Level
[messageComponent] :: Message -> Component
[messageScope] :: Message -> Scope
[messageText] :: Message -> Text

-- | Converts message some representation
type Converter a = Message -> a

-- | Returns function which accepts consumed value
type Consumer a = ContT () IO (a -> IO ())

-- | Make consumer
consumer :: (((a -> IO ()) -> IO ()) -> IO ()) -> Consumer a

-- | Message handler
type LogHandler = Consumer Message

-- | Convert consumer creater to logger creater
handler :: Converter a -> Consumer a -> Consumer Message
data LogConfig
LogConfig :: Map Component Level -> LogConfig
[_logConfigMap] :: LogConfig -> Map Component Level

-- | Default log config — info level
defCfg :: LogConfig

-- | Make log config by list of components and levels
logCfg :: [(Component, Level)] -> LogConfig

-- | Component config level lens
componentCfg :: Component -> Lens' LogConfig (Maybe Level)

-- | Get politics for specified component
componentLevel :: LogConfig -> Component -> Level

-- | Log
data Log
Log :: Component -> Scope -> (Message -> IO ()) -> IO () -> MVar LogConfig -> MVar [LogHandler] -> IO () -> Log

-- | Current log component
[logComponent] :: Log -> Component

-- | Current log scope
[logScope] :: Log -> Scope

-- | Log message, it is low-level function, i.e. it doesn't take into
--   account current component and scope and writes message as is
[logPost] :: Log -> Message -> IO ()

-- | Stop log and wait until it writes all
[logStop] :: Log -> IO ()

-- | Log config
[logConfig] :: Log -> MVar LogConfig

-- | Handlers list
[logHandlers] :: Log -> MVar [LogHandler]

-- | Restart all handlers
[logRestartHandlers] :: Log -> IO ()

-- | Create log, returns root logger for root component
--   
--   Messages from distinct threads and components are splitted in several
--   chans, where they are processed, and then messages combined back and
--   sent to log-thread
newLog :: LogConfig -> [LogHandler] -> IO Log

-- | Get root log, i.e. just drop current component and scope
rootLog :: Log -> Log

-- | Get log for specified component and scope
getLog :: Component -> Scope -> Log -> Log

-- | Get sub-log
subLog :: Component -> Scope -> Log -> Log

-- | Read log config
getLogConfig :: MonadIO m => Log -> m LogConfig

-- | Modify log config
updateLogConfig :: MonadIO m => Log -> (LogConfig -> LogConfig) -> m LogConfig

-- | Update log handlers, this restarts handlers thread
updateLogHandlers :: MonadIO m => Log -> ([LogHandler] -> [LogHandler]) -> m ()

-- | Write message to log for current component and scope
writeLog :: MonadIO m => Log -> Level -> Text -> m ()

-- | Wait log messages and stop log
stopLog :: MonadIO m => Log -> m ()
instance GHC.Show.Show System.Log.Simple.Base.Message
instance GHC.Read.Read System.Log.Simple.Base.Message
instance GHC.Classes.Ord System.Log.Simple.Base.Scope
instance GHC.Classes.Eq System.Log.Simple.Base.Scope
instance GHC.Classes.Ord System.Log.Simple.Base.Component
instance GHC.Classes.Eq System.Log.Simple.Base.Component
instance GHC.Enum.Bounded System.Log.Simple.Base.Level
instance GHC.Enum.Enum System.Log.Simple.Base.Level
instance GHC.Show.Show System.Log.Simple.Base.Level
instance GHC.Read.Read System.Log.Simple.Base.Level
instance GHC.Classes.Ord System.Log.Simple.Base.Level
instance GHC.Classes.Eq System.Log.Simple.Base.Level
instance Data.Default.Class.Default System.Log.Simple.Base.Level
instance GHC.Show.Show System.Log.Simple.Base.Component
instance Text.Format.FormatBuild System.Log.Simple.Base.Component
instance GHC.Read.Read System.Log.Simple.Base.Component
instance Data.String.IsString System.Log.Simple.Base.Component
instance GHC.Base.Monoid System.Log.Simple.Base.Component
instance Control.DeepSeq.NFData System.Log.Simple.Base.Component
instance GHC.Show.Show System.Log.Simple.Base.Scope
instance Text.Format.FormatBuild System.Log.Simple.Base.Scope
instance GHC.Read.Read System.Log.Simple.Base.Scope
instance Data.String.IsString System.Log.Simple.Base.Scope
instance GHC.Base.Monoid System.Log.Simple.Base.Scope
instance Control.DeepSeq.NFData System.Log.Simple.Base.Scope
instance System.Log.Simple.Base.HasParent System.Log.Simple.Base.Component
instance System.Log.Simple.Base.HasParent System.Log.Simple.Base.Scope
instance Control.DeepSeq.NFData System.Log.Simple.Base.Message
instance Data.Default.Class.Default System.Log.Simple.Base.LogConfig
instance GHC.Show.Show System.Log.Simple.Base.LogConfig

module System.Log.Simple.Chan
chan :: Chan a -> Consumer a

module System.Log.Simple.Monad
class (MonadIO m, MonadMask m) => MonadLog m
askLog :: MonadLog m => m Log
localLog :: MonadLog m => (Log -> Log) -> m a -> m a
newtype LogT m a
LogT :: ReaderT Log m a -> LogT m a
[runLogT] :: LogT m a -> ReaderT Log m a

-- | Run with no logging
noLog :: (MonadIO m, MonadMask m) => LogT m a -> m a

-- | Run <tt>LogT</tt> monad with <tt>Log</tt>
withLog :: Log -> LogT m a -> m a

-- | Run <tt>LogT</tt> monad with log config and handlers
runLog :: (MonadIO m, MonadMask m) => LogConfig -> [LogHandler] -> LogT m a -> m a

-- | Ask current component
askComponent :: MonadLog m => m Component

-- | Ask current scope
askScope :: MonadLog m => m Scope

-- | Log message
log :: MonadLog m => Level -> Text -> m ()

-- | Log message, same as <tt>log</tt>
sendLog :: MonadLog m => Level -> Text -> m ()

-- | Log component, also sets root scope
component :: MonadLog m => Text -> m a -> m a

-- | Create local scope
scope_ :: MonadLog m => Text -> m a -> m a

-- | Scope with log all exceptions
scope :: MonadLog m => Text -> m a -> m a

-- | Scope with log exception from <tt>MonadError</tt>
scopeM :: (MonadLog m, MonadError e m, Show e) => Text -> m a -> m a

-- | Scope with tracing result
scoper :: (MonadLog m, Show a) => Text -> m a -> m a
scoperM :: (MonadLog m, MonadError e m, Show e, Show a) => Text -> m a -> m a

-- | Trace value
trace :: (MonadLog m, Show a) => Text -> m a -> m a
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (System.Log.Simple.Monad.LogT m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (System.Log.Simple.Monad.LogT m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (System.Log.Simple.Monad.LogT m)
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader System.Log.Simple.Base.Log (System.Log.Simple.Monad.LogT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (System.Log.Simple.Monad.LogT m)
instance GHC.Base.Monad m => GHC.Base.Monad (System.Log.Simple.Monad.LogT m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (System.Log.Simple.Monad.LogT m)
instance GHC.Base.Functor m => GHC.Base.Functor (System.Log.Simple.Monad.LogT m)
instance (System.Log.Simple.Monad.MonadLog m, Control.Monad.Trans.Class.MonadTrans t, Control.Monad.Morph.MFunctor t, Control.Monad.IO.Class.MonadIO (t m), Control.Monad.Catch.MonadMask (t m)) => System.Log.Simple.Monad.MonadLog (t m)
instance Control.Monad.Trans.Class.MonadTrans System.Log.Simple.Monad.LogT
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.Catch.MonadMask m) => System.Log.Simple.Monad.MonadLog (System.Log.Simple.Monad.LogT m)

module System.Log.Simple.Stream
stream :: Handle -> Consumer Text
console :: Consumer Text

module System.Log.Simple.File
file :: FilePath -> Consumer Text

module System.Log.Simple.Text

-- | Default time format
defaultTimeFormat :: String
textFmt :: String -> String -> Converter Text

-- | Text log converter with default time format
text :: Converter Text
shortText :: Converter Text
msgOnly :: Converter Text


-- | Fast start
--   
--   Create log config:
--   
--   <pre>
--   myCfg = logCfg [("", Info), ("app", Trace), ("app.sub", Debug)]
--    
--   </pre>
--   
--   Create log and run log monad
--   
--   <pre>
--   run ∷ IO ()
--   run = runLog myCfg [handler text (file "out.log")] $ yourFunction
--    
--   </pre>
--   
--   Function within log monad:
--   
--   <pre>
--   yourFunction ∷ MonadLog m ⇒ m ()
--   yourFunction = component "app" $ scope "your" $ do
--   	sendLog Trace "Hello from your function"
--    
--   </pre>
--   
--   Each component can have different level in config, subcomponents are
--   specified with <a>.</a> Components have independent scopes Scopes can
--   be nested and separated with <a>/</a>:
--   
--   <pre>
--   function2 ∷ MonadLog m ⇒ m ()
--   function2 = component "app.sub" $ scope "foo" $ do
--   	scope "bar/baz" $ do
--   		sendLog Info "Component app.sub and scope foo<i>bar</i>baz"
--   		sendLog Trace "Invisible: app.sub configured with debug level"
--   	sendLog Info "Same component and scope foo"
--   	component "module" $ sendLog Info "Component module and root scope"
--    
--   </pre>
--   
--   You can update config with <tt>updateLogConfig</tt> function And
--   change handlers with <tt>updateLogHandlers</tt>
--   
--   There're also global logger <tt>globalLog</tt>, that can be used with
--   <tt>runGlobalLog</tt>
--   
--   <pre>
--   test ∷ IO ()
--   test = do
--   	updateLogHandlers globalLog ([handler text (file "test.log")]:)
--   	runGlobalLog $ sendLog Info "This will go to test.log too"
--    
--   </pre>
module System.Log.Simple
globalLog :: Log
runGlobalLog :: LogT IO a -> IO a
runConsoleLog :: LogConfig -> LogT IO a -> IO a
runLogMsgs :: (MonadIO m, MonadMask m) => LogConfig -> LogT m a -> m (a, [Message])
runLogTexts :: (MonadIO m, MonadMask m) => Converter Text -> LogConfig -> LogT m a -> m (a, [Text])