Commit a7a9d558 authored by Toralf Wittner's avatar Toralf Wittner
Browse files

Use bytestring builder in 'System.Logger.Message'.

parent 32979492

src/System/Logger.hs

+3 −6
Original line number Diff line number Diff line
@@ -46,7 +46,6 @@ import Control.Monad.IO.Class 
import Data.ByteString (ByteString)

import Data.ByteString.Char8 (pack)

import Data.Maybe (fromMaybe)

import Data.Monoid

import Data.String

import Data.UnixTime

import System.Date.Cache
@@ -170,13 +169,11 @@ level :: Logger -> Level 
level = logLevel . _settings

{-# INLINE level #-}



{-# INLINE putMsg #-}

putMsg :: MonadIO m => Logger -> Level -> Builder -> m ()

putMsg g l f = liftIO $ do

    let x = delimiter $ _settings g

    let m = render x (msg (l2b l) . f)

    d <- maybe (return "") (fmap (<> x)) (_getDate g)

    FL.pushLogStr (_logger g) $ FL.toLogStr (d <> m <> "\n")

    d <- maybe (return id) (liftM msg) (_getDate g)

    let m = render (delimiter $ _settings g) (d . msg (l2b l) . f)

    FL.pushLogStr (_logger g) (FL.toLogStr m)

  where

    l2b :: Level -> ByteString

    l2b Trace = "T"

src/System/Logger/Message.hs

+30 −14
Original line number Diff line number Diff line 
{-# LANGUAGE OverloadedStrings #-}



module System.Logger.Message where

module System.Logger.Message

    ( Builder

    , Msg

    , value

    , msg

    , msg'

    , field

    , render

    ) where



import Data.ByteString (ByteString)

import Data.List (intersperse)

import Data.Monoid



type Builder = Msg -> Msg



newtype Msg = Msg

    { parts :: [ByteString]

    } deriving (Eq, Ord, Show)

import qualified Data.ByteString.Lazy                as L

import qualified Data.ByteString.Lazy.Builder        as B

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



empty :: Msg

empty = Msg []

type Builder = Msg -> Msg

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



value :: ByteString -> Builder

value b = const $ Msg [b]

value b = const $ Msg [B.byteString b]



msg :: ByteString -> Builder

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

msg p (Msg m) = Msg (B.byteString p : m)



msg' :: ByteString -> Builder

msg' ""     m  = m

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

msg' p (Msg m) = Msg (B.byteString p : m)



field :: ByteString -> ByteString -> Builder

field k v (Msg m) = Msg (k <> "=" <> v : m)

field k v (Msg m) = Msg $

    B.byteString k <> B.byteString "=" <> B.byteString v : m



render :: ByteString -> Builder -> L.ByteString

render s f = finish

           . mconcat

           . intersperse (B.byteString s)

           . builders

           . f

           $ empty

  where

    finish = B.toLazyByteStringWith (B.untrimmedStrategy 128 256) "\n"

    empty  = Msg []

render :: ByteString -> Builder -> ByteString

render s f = mconcat . intersperse s . parts $ f empty

tinylog.cabal

+1 −1
Original line number Diff line number Diff line 
name:                 tinylog

version:              0.3

version:              0.3.1

synopsis:             Simplistic logging using fast-logger.

author:               Toralf Wittner

maintainer:           Toralf Wittner <tw@dtex.org>