log-effect 0.3.0.2 → 0.4.0.0

raw patch · 5 files changed

+130/−58 lines, 5 filesdep ~fast-loggerPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: fast-logger

API changes (from Hackage documentation)

Files

• Changelog.md +9/−0
• examples/IOLogger.hs +17/−0
• log-effect.cabal +4/−3
• src/Control/Eff/Log.hs +71/−38
• src/Control/Eff/Log/Simple.hs +29/−17

@@ -0,0 +1,9 @@+# Changelog++## Version 0.4++ * add a proxy to most `runLog` functions to not have to supply the full+   specialized type signature. Use something like `data Proxy a = Proxy` or+   the one from `tagged`.++ * remove `ShowLog` typeclass in favor of `ToLogString` from `fast-logger`.

@@ -0,0 +1,17 @@+{-# LANGUAGE OverloadedStrings #-}+module Main (main) where++import Control.Eff+import Control.Eff.Lift+import Control.Eff.Log+import System.Log.FastLogger++data Proxy a = Proxy++main :: IO ()+main = do+    loggerSet <- newStderrLoggerSet defaultBufSize+    pushLogStr loggerSet "logging from outer space^WIO\n"+    runLift $ runLogWithLoggerSet loggerSet (Proxy :: Proxy String) $+        logE ("logging from inner Eff" :: String)+    flushLogStr loggerSet

@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/  name:                log-effect-version:             0.3.0.2+version:             0.4.0.0 synopsis:            An extensible log effect using extensible-effects description:         Any help (especially documentation) is very welcome, homepage:            https://github.com/ibotty/log-effect@@ -13,7 +13,8 @@ -- copyright:            category:            Control, Effect, Logging build-type:          Simple--- extra-source-files:  +extra-source-files:    Changelog.md+                     , examples/IOLogger.hs cabal-version:       >=1.10  library@@ -24,7 +25,7 @@   build-depends:       base >=4.6 && <4.8                      , bytestring >=0.10.2 && <0.11                      , extensible-effects ==1.4.* || ==1.7.*-                     , fast-logger >=2.1 && <2.2+                     , fast-logger >=2.1.4 && <2.2                      , time >=1.4 && <1.5   hs-source-dirs:      src   default-language:    Haskell2010

@@ -1,30 +1,34 @@-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DeriveDataTypeable    #-}+{-# LANGUAGE DeriveFunctor         #-}+{-# LANGUAGE FlexibleContexts      #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators #-}-{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE OverloadedStrings     #-}+{-# LANGUAGE RankNTypes            #-}+{-# LANGUAGE TypeOperators         #-} module Control.Eff.Log   ( Log(Log, logLine)-  , ShowLog(showLog)   , logE   , filterLog+  , filterLog'   , runLogPure-  , runLogStdErr+  , runLogStdout+  , runLogStderr   , runLogFile+  , runLogWithLoggerSet   , runLog   ) where -import Control.Applicative ((<$>))-import Control.Eff ( Eff, Member, SetMember, VE(..), (:>)-                   , admin, handleRelay, inj, interpose, send)-import Control.Eff.Lift (Lift, lift)-import Data.Typeable (Typeable, Typeable1)-import System.IO (stderr)-import System.Log.FastLogger (LoggerSet, LogStr, defaultBufSize, fromLogStr, newLoggerSet, pushLogStr, toLogStr)+import Control.Applicative   ((<$>), (<*))+import Control.Eff           ((:>), Eff, Member, SetMember, VE (..), admin,+                              handleRelay, inj, interpose, send)+import Control.Eff.Lift      (Lift, lift)+import Data.Monoid           ((<>))+import Data.Typeable         (Typeable, Typeable1)+import System.Log.FastLogger (LogStr, LoggerSet, ToLogStr, defaultBufSize,+                              flushLogStr, fromLogStr, newFileLoggerSet,+                              newStderrLoggerSet, newStdoutLoggerSet,+                              pushLogStr, toLogStr)+ import qualified Data.ByteString.Char8 as B8  data Log a v = Log@@ -32,12 +36,6 @@   , logNext :: v   } deriving (Typeable, Functor) -class ShowLog l where-    showLog :: l -> LogStr--instance ShowLog String where-    showLog = toLogStr- -- | a monadic action that does the real logging type Logger m l = forall v. Log l v -> m () @@ -61,6 +59,10 @@         go (E req) = handleRelay req go performLog         performLog l = lift (logger l) >> go (logNext l) +-- | Filter Log entries with a predicate.+--+-- Note that, most of the time an explicit type signature for the predicate+-- will be required. filterLog :: (Typeable l, Member (Log l) r)   => (l -> Bool) -> Eff r a -> Eff r a filterLog f = go . admin@@ -68,24 +70,55 @@         go (E req) = interpose req go filter'           where filter' (Log l v) = if f l then send (<$> req) >>= go                                            else go v-runLogStdErr :: (Typeable l, ShowLog l, SetMember Lift (Lift IO) r)-  => Eff (Log l :> r) a -> Eff r a-runLogStdErr = runLog stdErrLogger -stdErrLogger :: ShowLog l => Logger IO l-stdErrLogger = B8.hPutStrLn stderr . fromLogStr . showLog . logLine+-- | Filter Log entries with a predicate and a proxy.+--+-- This is the same as 'filterLog' but with a "proxy l" for type inference.+filterLog' :: (Typeable l, Member (Log l) r)+  => (l -> Bool) -> proxy l -> Eff r a -> Eff r a+filterLog' predicate _ = filterLog predicate +-- | Log to stdout.+runLogStdout :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)+  => proxy l -> Eff (Log l :> r) a -> Eff r a+runLogStdout proxy eff = do+    s <- lift $ newStdoutLoggerSet defaultBufSize+    runLogWithLoggerSet s proxy eff <* lift (flushLogStr s)++-- | Log to stderr.+runLogStderr :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)+  => proxy l -> Eff (Log l :> r) a -> Eff r a+runLogStderr proxy eff = do+    s <- lift $ newStderrLoggerSet defaultBufSize+    runLogWithLoggerSet s proxy eff <* lift (flushLogStr s)+ -- | Log to file.-runLogFile :: (Typeable l, ShowLog l, SetMember Lift (Lift IO) r)-  => FilePath -> Eff (Log l :> r) a -> Eff r a-runLogFile f eff = do-    s <- lift (newLoggerSet defaultBufSize (Just f))-    runLogWithLoggerSet s eff+runLogFile :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)+  => FilePath -> proxy l -> Eff (Log l :> r) a -> Eff r a+runLogFile f proxy eff = do+    s <- lift $ newFileLoggerSet defaultBufSize f+    runLogWithLoggerSet s proxy eff <* lift (flushLogStr s)  -- | Log to a file using a 'LoggerSet'.-runLogWithLoggerSet :: (Typeable l, ShowLog l, SetMember Lift (Lift IO) r)-  => LoggerSet -> Eff (Log l :> r) a -> Eff r a-runLogWithLoggerSet s = runLog (fileLogger s)+--+-- Note, that you will still have to call 'flushLogStr' on the 'LoggerSet'+-- at one point.+--+-- With that function you can combine a logger in a surrounding IO action+-- with a logger in the 'Eff' effect.+--+-- >data Proxy a = Proxy+-- >+-- > main :: IO ()+-- > main = do+-- >     loggerSet <- newStderrLoggerSet defaultBufSize+-- >     pushLogStr loggerSet "logging from outer space^WIO\n"+-- >     runLift $ runLogWithLoggerSet loggerSet (Proxy :: Proxy String) $+-- >         logE ("logging from within Eff" :: String)+-- >     flushLogStr loggerSet+runLogWithLoggerSet :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)+  => LoggerSet -> proxy l -> Eff (Log l :> r) a -> Eff r a+runLogWithLoggerSet s _ = runLog (loggerSetLogger s) -fileLogger :: ShowLog l => LoggerSet -> Logger IO l-fileLogger loggerSet = pushLogStr loggerSet . showLog . logLine+loggerSetLogger :: ToLogStr l => LoggerSet -> Logger IO l+loggerSetLogger loggerSet = pushLogStr loggerSet . (<> "\n") . toLogStr . logLine

@@ -1,9 +1,10 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE TypeOperators #-}-{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE DeriveDataTypeable    #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverloadedStrings     #-}+{-# LANGUAGE RankNTypes            #-}+{-# LANGUAGE TypeOperators         #-} module Control.Eff.Log.Simple   ( SimpleLog   , Severity(..)@@ -18,16 +19,32 @@   , panic   ) where -import Prelude hiding (error)-import Control.Eff (Eff, Member)+import Control.Eff           (Eff, Member) import Control.Eff.Log-import Data.Monoid ((<>))-import Data.Typeable (Typeable)-import System.Log.FastLogger (toLogStr)+import Data.Monoid           ((<>))+import Data.Typeable         (Typeable)+import Prelude               hiding (error)+import System.Log.FastLogger (ToLogStr, toLogStr) -data Severity = DEBUG | INFO | NOTICE | WARNING | ERROR | CRITICAL | ALERT | PANIC+data Severity =+    DEBUG | INFO | NOTICE | WARNING | ERROR | CRITICAL | ALERT | PANIC   deriving (Bounded, Enum, Eq, Ord, Read, Show, Typeable) +type SimpleLog a = Log (Severity, a)++instance ToLogStr Severity where+    toLogStr DEBUG    = "DEBUG"+    toLogStr INFO     = "INFO"+    toLogStr NOTICE   = "NOTICE"+    toLogStr WARNING  = "WARNING"+    toLogStr ERROR    = "ERROR"+    toLogStr CRITICAL = "CRITICAL"+    toLogStr ALERT    = "ALERT"+    toLogStr PANIC    = "PANIC"++instance ToLogStr a => ToLogStr (Severity, a) where+    toLogStr (sev, line) = "[" <> toLogStr sev <> "] " <> toLogStr line <> "\n"+ logTo :: (Typeable l, Member (Log (Severity, l)) r)   => Severity -> l -> Eff r () logTo sev line = logE (sev, line)@@ -55,8 +72,3 @@  panic :: (Typeable l, Member (Log (Severity, l)) r) => l -> Eff r () panic = logTo PANIC--type SimpleLog a = Log (Severity, a)--instance ShowLog a => ShowLog (Severity, a) where-    showLog (sev, line) = "[" <> toLogStr (show sev) <> "] " <> showLog line