Copyright	(c) 2019 Version Cloud
License	BSD3
Maintainer	Jorah Gao <gqk007@gmail.com>
Stability	experimental
Portability	portable
Safe Haskell	None
Language	Haskell2010

Logging

Contents

Logging THs
Types

Description

A python logging style log library.

A full example:

  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE QuasiQuotes       #-}
  {-# LANGUAGE RecordWildCards   #-}
  {-# LANGUAGE TemplateHaskell   #-}


  module Main (main) where

  import           Data.Aeson.QQ.Simple (aesonQQ)
  import           Prelude hiding (error)
  import           Logging (runJson, debug, info, warn, error, fatal, logv)

  main :: IO ()
  main = runJson manager app

  myLogger = "MyLogger.Main"

  app :: IO ()
  app = do
    $(debug) myLogger "this message should print into MyLogger"
    $(info) myLogger "this message should print into MyLogger"
    $(warn) myLogger "this message should print into MyLogger"
    $(error) myLogger "this message should print into MyLogger"
    $(fatal) myLogger "this message should print into MyLogger"
    $(logv) myLogger "LEVEL 100" "this message should print into MyLogger"

  -- The best practice is putting all config into a separate file,
  -- e.g "Logging.json"
  manager = [aesonQQ|{
    "loggers": {
      "root": {
        "level": "DEBUG",
        "handlers": ["console"],
        "propagate": false
      },
      "MyLogger": {
        "level": "INFO",
        "filterer": ["MyLogger.Main"],
        "handlers": ["file"],
        "propagate": false
      }
    },
    "handlers": {
      "console": {
        "type": "StreamHandler",
        "stream": "stderr",
        "level": "DEBUG",
        "formatter": "defaultFormatter"
      },
      "file": {
        "type": "FileHandler",
        "level": "INFO",
        "formatter": "defaultFormatter",
        "file": "./default.log"
      }
    },
    "formatters": {
      "defaultFormatter": {
        "fmt": "%(asctime)s - %(level)s - %(logger)s - %(pathname)s/%(filename)s:%(lineno)d] %(message)s"
      }
    }
  }|]

Synopsis

run :: Manager -> IO a -> IO a
runJson :: Value -> IO a -> IO a
jsonToManager :: Value -> IO Manager
stderrHandler :: StreamHandler
stdoutHandler :: StreamHandler
defaultRoot :: Sink
logv :: ExpQ
debug :: ExpQ
info :: ExpQ
warn :: ExpQ
error :: ExpQ
fatal :: ExpQ
class Handler a where
- getLevel :: a -> Level
- setLevel :: a -> Level -> a
- getFilterer :: a -> Filterer
- setFilterer :: a -> Filterer -> a
- getFormatter :: a -> Formatter
- setFormatter :: a -> Formatter -> a
- acquire :: a -> IO ()
- release :: a -> IO ()
- with :: a -> (a -> IO b) -> IO b
- emit :: a -> LogRecord -> IO ()
- flush :: a -> IO ()
- close :: a -> IO ()
- handle :: a -> LogRecord -> IO Bool
data Manager = Manager {
- root :: Sink
- sinks :: Map String Sink
- disabled :: Bool
- catchUncaughtException :: Bool
}
data Sink = Sink {
- logger :: Logger
- level :: Level
- filterer :: Filterer
- handlers :: [HandlerT]
- disabled :: Bool
- propagate :: Bool
}
data HandlerT where
- HandlerT :: Handler a => a -> HandlerT
data StreamHandler = StreamHandler {
- stream :: Handle
- level :: Level
- filterer :: Filterer
- formatter :: Formatter
- lock :: MVar ()
}
data Formatter = Formatter {
- fmt :: String
- datefmt :: String
}
type Filterer = [Filter]
data Filter = Filter {
- name :: String
- nlen :: Int
}
data LogRecord = LogRecord {
- logger :: Logger
- level :: Level
- message :: String
- filename :: String
- packagename :: String
- modulename :: String
- lineno :: Int
- created :: ZonedTime
}
newtype Level = Level Int
type Logger = String

Documentation

run :: Manager -> IO a -> IO a Source #

Run a logging environment.

You should always write you application inside a logging environment.

rename "main" function to "originMain" (or whatever you call it)
write "main" as below

main :: IO ()
main = run manager originMain
...

runJson :: Value -> IO a -> IO a Source #

Run a logging environment from JSON Value.

A combinator of run and jsonToManager.

jsonToManager :: Value -> IO Manager Source #

Make a Manager from JSON Value.

stderrHandler :: StreamHandler Source #

A StreamHandler bound to stderr

stdoutHandler :: StreamHandler Source #

A StreamHandler bound to stdout

defaultRoot :: Sink Source #

Default root sink which is used by jsonToManager when root is missed.

You can use it when you make Manager manually.

Logging THs

logv :: ExpQ Source #

Log "message" with the severity "level".

The missing type signature: MonadIO m => Logger -> Level -> String -> m ()

debug :: ExpQ Source #

Log "message" with a specific severity.