co-log is a composable and configurable logging framework. It
combines all the benefits of Haskell idioms to provide a reasonable
and convenient interface. Although the library design uses some advanced
concepts in its core, we are striving to provide beginner-friendly API. The
library also provides the complete documentation with a lot of beginner-friendly
examples, explanations and tutorials to guide users. The combination of a
pragmatic approach to logging and fundamental Haskell abstractions allows us to
create a highly composable and configurable logging framework.
If you're interested in how different Haskell typeclasses are used to
implement core functions of co-log, you can read the following blog
post which goes into detail about the internal implementation specifics:
Co-Log is a family of repositories for a composable and configurable logging
framework co-log.
Here is the list of currently available repositories and libraries that you can check out:
co-log-core |
lightweight package with basic data types and general idea which depends only on base |
 |
co-log |
taggless final implementation of logging library based on co-log-core |
 |
co-log-polysemy |
implementation of logging library based on co-log-core and the polysemy extensible effects library. |
 |
co-log-benchmarks |
benchmarks of the co-log library |
- |
Logging library based on co-log-core
package. Provides ready-to-go implementation of logging. This README contains
How to tutorial on using this library. This tutorial explains step by step how
to integrate co-log into small basic project, specifically how to replace
putStrLn used for logging with library provided logging.
All code below can be compiled and run with the following commands:
$ cabal build
$ cabal exec readmeSince this is a literate haskell file, we need to specify all our language extensions and imports up front.
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
import Control.Monad.IO.Class (MonadIO, liftIO)
import Colog (Message, WithLog, cmap, fmtMessage, logDebug, logInfo, logTextStdout, logWarning,
usingLoggerT)
import qualified Data.Text as Text
import qualified Data.Text.IO as TextIOConsider the following function that reads lines from stdin and outputs
different feedback depending on the line size.
processLinesBasic :: IO ()
processLinesBasic = do
line <- TextIO.getLine
case Text.length line of
0 -> do
-- here goes logging
TextIO.putStrLn ">>>> Empty input"
processLinesBasic
n -> do
TextIO.putStrLn ">>>> Correct input"
TextIO.putStrLn $ "Line length: " <> Text.pack (show n)This code mixes application logic with logging of the steps. It's convenient to
have logging to observe behavior of the application. But putStrLn is very
simple and primitive way to log things.
In order to use co-log library, we need to refactor processLinesBasic
function in the following way:
processLinesLog :: (WithLog env Message m, MonadIO m) => m ()
processLinesLog = do
line <- liftIO TextIO.getLine
case Text.length line of
0 -> do
-- here goes logging
logWarning "Empty input"
processLinesLog
n -> do
logDebug "Correct line"
logInfo $ "Line length: " <> Text.pack (show n)Let's summarize required changes:
- Make type more polymorphic:
(WithLog env Message m, MonadIO m) => m () - Add
liftIOto allIOfunctions. - Replace
putStrLnwith properlog*function.
Let's run both functions:
main :: IO ()
main = do
processLinesBasic
let action = cmap fmtMessage logTextStdout
usingLoggerT action processLinesLogAnd here is how output looks like:
To provide a more user-friendly introduction to the library, we've
created the tutorial series which introduces the main concepts behind co-log
smoothly, please check more details here.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent