Remove `LoggerT` and change `MonadLogger` class.

{-# LANGUAGE OverloadedStrings #-}

-- | Small layer on top of @fast-logger@ which adds log-levels and

-- timestamp support and not much more.

module System.Logger

    ( Level    (..)

    , Output   (..)

    , err

    , fatal

    , logM

    , traceM

    , debugM

    , infoM

    , warnM

    , errM

    , fatalM

    , iso8601UTC

    , module M

    )

    }

data Settings = Settings

    { logLevel  :: Level

    , output    :: Output

    , format    :: DateFormat

    , delimiter :: ByteString

    , bufSize   :: BufSize

    { logLevel  :: Level      -- ^ messages below this log level will be suppressed

    , output    :: Output     -- ^ log sink

    , format    :: DateFormat -- ^ the timestamp format (use \"\" to disable timestamps)

    , delimiter :: ByteString -- ^ text to intersperse between fields of a log line

    , bufSize   :: BufSize    -- ^ how many bytes to buffer before commiting to sink

    } deriving (Eq, Ord, Show)

data Output

iso8601UTC :: DateFormat

iso8601UTC = "%Y-%0m-%0dT%0H:%0M:%0SZ"

-- | Default settings for use with 'new':

--

--   * 'logLevel'  = 'Debug'

--

--   * 'output'    = 'StdOut'

--

--   * 'format'    = 'iso8601UTC'

--

--   * 'delimiter' = \", \"

--

--   * 'bufSize'   = 'FL.defaultBufSize'

--

defSettings :: Settings

defSettings = Settings Debug StdOut iso8601UTC ", " FL.defaultBufSize

-- | Create a new 'Logger' with the given 'Settings'.

-- Please note that the 'logLevel' can be dynamically adjusted by setting

-- the environment variable @LOG_LEVEL@ accordingly. Likewise the buffer

-- size can be dynamically set via @LOG_BUFFER@.

new :: MonadIO m => Settings -> m Logger

new s = liftIO $ do

    n <- fmap (readNote "Invalid LOG_BUFFER") <$> lookupEnv "LOG_BUFFER"

    fmt :: DateFormat -> UnixTime -> IO ByteString

    fmt d = return . formatUnixTimeGMT (template d)

-- | Invokes 'new' with default settings and the given output as log sink.

create :: MonadIO m => Output -> m Logger

create p = new defSettings { output = p }

    [(a, "")] -> a

    _         -> error m

-- | Logs a message with the given level if greater of equal to the

-- logger's threshold.

log :: MonadIO m => Logger -> Level -> (Msg -> Msg) -> m ()

log g l m = unless (level g > l) . liftIO $ putMsg g l m

{-# INLINE log #-}

logM :: MonadIO m => Logger -> Level -> m (Msg -> Msg) -> m ()

logM g l m = unless (level g > l) $ m >>= putMsg g l

{-# INLINE logM #-}

-- | Abbreviation for 'log' using the corresponding log level.

trace, debug, info, warn, err, fatal :: MonadIO m => Logger -> (Msg -> Msg) -> m ()

trace g = log g Trace

debug g = log g Debug

{-# INLINE err   #-}

{-# INLINE fatal #-}

traceM, debugM, infoM, warnM, errM, fatalM :: MonadIO m => Logger -> m (Msg -> Msg) -> m ()

traceM g = logM g Trace

debugM g = logM g Debug

infoM  g = logM g Info

warnM  g = logM g Warn

errM   g = logM g Error

fatalM g = logM g Fatal

{-# INLINE traceM #-}

{-# INLINE debugM #-}

{-# INLINE infoM  #-}

{-# INLINE warnM  #-}

{-# INLINE errM   #-}

{-# INLINE fatalM #-}

-- | Force buffered bytes to output sink.

flush :: MonadIO m => Logger -> m ()

flush = liftIO . FL.flushLogStr . _logger

-- | Closes the logger.

close :: MonadIO m => Logger -> m ()

close g = liftIO $ do

    fromMaybe (return ()) (_closeDate g)

    FL.rmLoggerSet (_logger g)

-- | Inspect this logger's threshold.

level :: Logger -> Level

level = logLevel . _settings

{-# INLINE level #-}

-- file, You can obtain one at http://mozilla.org/MPL/2.0/.

{-# LANGUAGE FlexibleContexts #-}

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module System.LoggerT

    ( LoggerT

    , MonadLogger (..)

    , runLoggerT

module System.Logger.Class

    ( MonadLogger (..)

    , trace

    , debug

    , info

    , warn

    , err

    , fatal

    , L.Level    (..)

    , L.Output   (..)

where

import Prelude hiding (log)

import Control.Applicative

import Control.Monad.Catch

import Control.Monad.Reader

import System.Logger (Logger, Level (..))

import System.Logger.Message as M

import qualified System.Logger as L

newtype LoggerT m a = LoggerT

    { unwrap :: ReaderT Logger m a

    } deriving ( Functor

               , Applicative

               , Monad

               , MonadIO

               , MonadThrow

               , MonadCatch

               , MonadReader Logger

               , MonadTrans

               )

class MonadIO m => MonadLogger m where

    logger :: m Logger

    prefix :: m (Msg -> Msg)

    prefix = return id

    log :: Level -> (Msg -> Msg) -> m ()

    log l m = do

        g <- logger

        p <- prefix

        L.log g l (p . m)

    logM :: Level -> m (Msg -> Msg) -> m ()

    logM l m = do

        g <- logger

        p <- prefix

        L.logM g l ((p .) `liftM` m)

instance (MonadIO m, MonadReader Logger m) => MonadLogger (ReaderT r m) where

    log l m = lift ask >>= \g -> L.log g l m

    trace, debug, info, warn, err, fatal :: (Msg -> Msg) -> m ()

-- | Abbreviation for 'log' using the corresponding log level.

trace, debug, info, warn, err, fatal :: MonadLogger m => (Msg -> Msg) -> m ()

trace = log Trace

debug = log Debug

info  = log Info

err   = log Error

fatal = log Fatal

    traceM, debugM, infoM, warnM, errM, fatalM :: m (Msg -> Msg) -> m ()

    traceM = logM Trace

    debugM = logM Debug

    infoM  = logM Info

    warnM  = logM Warn

    errM   = logM Error

    fatalM = logM Fatal

    flush :: m ()

    flush = logger >>= L.flush

    close :: m ()

    close = logger >>= L.close

instance MonadIO m => MonadLogger (LoggerT m) where

    logger = LoggerT ask

instance (MonadIO m, MonadReader Logger m) => MonadLogger (ReaderT r m) where

    logger = lift ask

runLoggerT :: MonadIO m => L.Logger -> LoggerT m a -> m a

runLoggerT l m = runReaderT (unwrap m) l

import qualified Data.Text.Lazy.Encoding             as T

import qualified Data.ByteString.Lazy                as L

import qualified Data.ByteString.Lazy.Builder        as B

import qualified Data.ByteString.Lazy.Builder.ASCII  as B

import qualified Data.ByteString.Lazy.Builder.Extras as B

-- | Convert some value to a 'Builder'.

class ToBytes a where

    bytes :: a -> Builder

    bytes True  = val "True"

    bytes False = val "False"

-- | Type representing log messages.

newtype Msg = Msg { builders :: [Builder] }

-- | Log some value.

msg :: ToBytes a => a -> Msg -> Msg

msg p (Msg m) = Msg (bytes p : m)

-- | Log some field, i.e. a key-value pair delimited by \"=\".

field, (=:) :: ToBytes a => ByteString -> a -> Msg -> Msg

field k v (Msg m) = Msg $ bytes k <> B.byteString "=" <> bytes v : m

(=:) = field

infixr 5 +++

-- | Concatenate two 'ToBytes' values.

(+++) :: (ToBytes a, ToBytes b) => a -> b -> Builder

a +++ b = bytes a <> bytes b

-- | Type restriction. Useful to disambiguate string literals when

-- using @OverloadedStrings@ pragma.

val :: ByteString -> Builder

val = bytes

-- | Intersperse parts of the log message with the given delimiter and

-- render the whole builder into a 'L.ByteString'.

render :: ByteString -> (Msg -> Msg) -> L.ByteString

render s f = finish

           . mconcat

name:                 tinylog

version:              0.7.2

version:              0.8

synopsis:             Simplistic logging using fast-logger.

author:               Toralf Wittner

maintainer:           Toralf Wittner <tw@dtex.org>

    exposed-modules:

          System.Logger

        , System.Logger.Class

        , System.Logger.Message

        , System.LoggerT

    build-depends:

          base         == 4.*

        , bytestring   >= 0.10

        , date-cache   >= 0.3

        , exceptions   >= 0.4

        , fast-logger  >= 2.1.4 && < 2.2

        , mtl          >= 2.1

        , text         >= 0.11  && < 1.2