Log immediately to file

[mb720]

Hi!

Based on the tutorial code here and here, I'm attempting to log to a file in my app.

I'm currently facing the issue that I can't get co-log to log to the file while the program is running. The log message ends up in the file only after the program is finished.

Here's my code:

{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE PatternSynonyms            #-}
{-# LANGUAGE ScopedTypeVariables        #-}
{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs               #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE FlexibleInstances          #-}

module Main where

import           Prelude                 hiding ( log )

import           Colog                          ( pattern I
                                                , Message
                                                , LogAction
                                                , withLogTextFile
                                                , WithLog
                                                , HasLog(..)
                                                , cmapM
                                                , upgradeMessageAction
                                                , log
                                                , fmtRichMessageDefault
                                                , defaultFieldMap
                                                , logTextStdout
                                                )

import           Control.Concurrent             ( threadDelay )

import           Control.Monad.IO.Class         ( MonadIO(..) )
import           Control.Monad.Reader           ( MonadReader
                                                , ReaderT(..)
                                                )

data Env m = Env
    { httpsPort :: !Int
    , httpPort :: !Int
    , logAction  :: !(LogAction m Message)
    }

instance HasLog (Env m) Message m where
  getLogAction :: Env m -> LogAction m Message
  getLogAction = logAction
  {-# INLINE getLogAction #-}

  setLogAction :: LogAction m Message -> Env m -> Env m
  setLogAction newLogAction env = env { logAction = newLogAction }
  {-# INLINE setLogAction #-}

runApp :: Env App -> App a -> IO a
runApp env app = runReaderT (unApp app) env

main = withLogTextFile "myApp.log" $ \textFileLogAction ->
  let myLogAction = modifyLogAction textFileLogAction
  in  runApp (simpleEnv myLogAction) simpleApp
where
  simpleApp = do
    log I "The log message"
    liftIO $ threadDelay (5 * 10 ^ 6)

simpleEnv :: LogAction App Message -> Env App
simpleEnv appLogging =
  Env { httpsPort = 8443, httpPort = 8080, logAction = appLogging }

modifyLogAction logAction =
  let combinedLogAction = logTextStdout <> logAction
      messageAction     = cmapM fmtRichMessageDefault combinedLogAction
  in  upgradeMessageAction defaultFieldMap messageAction

newtype App a = App {
      unApp :: ReaderT (Env App) IO a
    } deriving (Functor, Applicative, Monad, MonadIO, MonadReader (Env App))

The log message is printed to standard out right away but only shows up in the log file at the end of the program (after the five seconds delay).

As you might have guessed from the Env, I'd like to use co-log for a web server where it's important to have logs during the web server's execution.

I was wondering if there's some way to configure the log action to log to the file immediately.

Thanks a lot! :-)

---

My Stack resolver is lts-14.16.

[chshersh]

@mb720 Thanks for opening the issue! I see how this can be inconvenient. I believe one of the solutions to this problem is to use hFlush after logging something. This sounds like a good thing to do by default, so we'll make sure this change will be included in the next co-log release. But for now, what you can do is to copy the following implementation of withLogTextFile and use it instead of the library version:

withLogTextFile :: forall m r . MonadIO m => FilePath -> (LogAction m T.Text -> IO r) -> IO r
withLogTextFile path action = withFile path AppendMode $ action . logTextFlushHandle
  where
    logTextFlushHandle :: Handle -> LogAction m T.Text
    logTextFlushHandle handle = LogAction $ \msg -> liftIO $ do
        TIO.hPutStrLn handle msg
        hFlush handle

[mb720]

Thanks a lot, this worked like a charm after adding these imports:

import qualified Data.Text                     as T
import qualified Data.Text.IO                  as TIO
import           System.IO

Yes, I agree that making this the default is a good idea!