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


-- | Simple log for Haskell
--   
--   Log library for Haskell
@package simple-log
@version 0.9.5

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
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
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 Data.Default.Class.Default System.Log.Simple.Base.LogConfig
instance GHC.Show.Show System.Log.Simple.Base.LogConfig
instance Lens.Micro.Internal.Ixed System.Log.Simple.Base.LogConfig
instance Lens.Micro.Internal.At System.Log.Simple.Base.LogConfig
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 Control.DeepSeq.NFData System.Log.Simple.Base.Message
instance System.Log.Simple.Base.HasParent System.Log.Simple.Base.Component
instance System.Log.Simple.Base.HasParent System.Log.Simple.Base.Scope
instance GHC.Show.Show System.Log.Simple.Base.Scope
instance Text.Format.Formattable System.Log.Simple.Base.Scope
instance GHC.Read.Read System.Log.Simple.Base.Scope
instance Data.String.IsString System.Log.Simple.Base.Scope
instance Data.Semigroup.Semigroup System.Log.Simple.Base.Scope
instance GHC.Base.Monoid System.Log.Simple.Base.Scope
instance Control.DeepSeq.NFData System.Log.Simple.Base.Scope
instance GHC.Show.Show System.Log.Simple.Base.Component
instance Text.Format.Formattable System.Log.Simple.Base.Component
instance GHC.Read.Read System.Log.Simple.Base.Component
instance Data.String.IsString System.Log.Simple.Base.Component
instance Data.Semigroup.Semigroup System.Log.Simple.Base.Component
instance GHC.Base.Monoid System.Log.Simple.Base.Component
instance Control.DeepSeq.NFData System.Log.Simple.Base.Component
instance Data.Default.Class.Default System.Log.Simple.Base.Level
instance Text.Format.Formattable System.Log.Simple.Base.Level

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

-- | Modify config, same as <tt>updateLogConfig</tt>, but within
--   <tt>MonadLog</tt>
modifyLogConfig :: MonadLog m => (LogConfig -> LogConfig) -> m LogConfig

-- | Modify handlers, same as <tt>updateLogHandlers</tt>, but within
--   <tt>MonadLog</tt>
modifyLogHandlers :: MonadLog m => ([LogHandler] -> [LogHandler]) -> m ()
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 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)
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)

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

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

module System.Log.Simple.Text

-- | Default time format
defaultTimeFormat :: String
textFmt :: FormatResult r => String -> String -> Converter r

-- | Text log converter with default time format
text :: FormatResult r => Converter r
shortText :: FormatResult r => Converter r
msgOnly :: FormatResult r => Converter r


-- | 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 '.' Components have independent scopes Scopes can be
--   nested and separated with '/':
--   
--   <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> (or
--   <tt>modifyLogConfig</tt> within log monad) function And change
--   handlers with <tt>updateLogHandlers</tt> (<tt>modifyLogHandlers</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 $ do
--   		sendLog Info "This will go to test.log too"
--   		modifyLogConfig (set (ix "") Debug)
--   		sendLog Debug "Now debug is logged too"
--    
--   </pre>
module System.Log.Simple
globalLog :: Log
runGlobalLog :: LogT m a -> m a
runConsoleLog :: (MonadIO m, MonadMask m) => LogConfig -> LogT m a -> m 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])
