Easy Logging for Haskell
Easy-logger can be used to easily create logs, without handling any Monad. Just log as you go. The
package provides logging for code that lives in the IO Monad, implements MonadIO m, as well as
for pure code.
Usage
Initialise the logger for your package and start logging:
{-# LANGUAGE TemplateHaskell #-}
import EasyLogger
import qualified Data.Text as T
main :: IO ()
main = do
$(initLogger) (LogFile "package.log") LogDebug
$(logInfo) ("Starting App" :: T.Text)
...
# At the end of your program, flush the buffers:
finalizeAllLoggers
The log output looks like this:
$ cat package.log
[INFO #22-Oct-2021 12:27:23] Starting App @(main:Main
If you use libraries, including your own package library, to log from a file outside of
Main.hs you need to make the library package name available and enable the logging specifically. For this create following file:
{-# LANGUAGE TemplateHaskell #-}
module MyPackage.Logging
( enableMyPackageLogging
, disableMyPackageLogging
) where
import EasyLogger
enableMyPackageLogging :: LogDestination -> LogLevel -> IO ()
enableMyPackageLogging = $(initLogger)
disableMyPackageLogging :: IO ()
disableMyPackageLogging = $(finalizeLogger)
and then enable it:
{-# LANGUAGE TemplateHaskell #-}
import EasyLogger
import MyPackage.Logging
import qualified Data.Text as T
main :: IO ()
main = do
$(initLogger) (LogFile "package.log") LogDebug
enableMyPackageLogging (LogFile "package.log") LogDebug
...
# At the end of your program, flush the buffers:
finalizeAllLoggers
You can also include the logs of all the libraries that you use and which use the easy-logger
package for logging:
{-# LANGUAGE TemplateHaskell #-}
import EasyLogger
import qualified Data.Text as T
main :: IO ()
main = do
$(initLoggerAllPackages) (LogFile "package.log") LogAll True
$(logInfo) ("Starting App" :: T.Text)
...
# At the end of your program, flush the buffers:
finalizeAllLoggers
You want to log in pure code without wrapping anything in a Monad? Here you go:
fromEither :: Either String Int -> Int
fromEither (Right v) = v
fromEither (Left str) = $(pureLogPrintError) ("Parse error: " <> T.pack str) defaultValue
defaultValue = 0
Under the hood pureLogPrintError uses unsafePerformIO to log. The return value, i.e.
defaultValue in the example, ensures that the log is actually executed when the error occurs.
Log Levels and Destinations
The available log levels are:
-- | Log Level. Levels are sorted. `All` < `Debug` < `Info` < `Warning` < `Error`.
-- None disables all logging. Default: All
data LogLevel
= LogNone
| LogAll
| LogDebug
| LogInfo
| LogWarning
| LogError
deriving (Show, Read, Bounded, Enum, Eq, Ord)
The logger can be used to log to stderr, stdout or a file:
-- | Logging destination. See also `setLoggingDestination`.
data LogDestination
= LogStdErr
| LogStdOut
| LogFile FilePath
Library
If you are exposing a library (including your own library), let your user turn on/off the logging
for your library. The Template-Haskell code ensures that your package name is provided to the
logger, and thus logging for this module only is turned on/off.
{-# LANGUAGE TemplateHaskell #-}
module My.Great.Package.Logging
( enableMyGreatPackageLogging
, disableMyGreatPackageLogging
) where
import EasyLogger
enableMyGreatPackageLogging :: LogDestination -> LogLevel -> IO ()
enableMyGreatPackageLogging = $(initLogger)
disableMyGreatPackageLogging :: IO ()
disableMyGreatPackageLogging = $(finalizeLogger)
