LogAnalysis.hs

{-# OPTIONS_GHC -Wall #-}
module LogAnalysis where
import Log
import Data.List (sortBy, isInfixOf)

parseMessage :: String -> MaybeLogMessage
parseMessage m = case lineHead of
                  "I" -> ValidLM (infoMessage lineRest)
                  "E" -> ValidLM (errorMessage lineRest)
                  "W" -> ValidLM (warnMessage lineRest)
                  _   -> InvalidLM m
    where lineHead = head (words m)
          lineRest = drop 1 (words m)

infoMessage :: [String] -> LogMessage
infoMessage items = LogMessage Info time message
  where time = parseTimeStamp (head items)
        message = (unwords (drop 1 items))

warnMessage :: [String] -> LogMessage
warnMessage items = LogMessage Warning time message
  where time = parseTimeStamp (head items)
        message = (unwords (drop 1 items))

errorMessage :: [String] -> LogMessage
errorMessage items = LogMessage (Error errorCode) time message
  where errorCode = parseErrorLevel (head items)
        time = parseTimeStamp (head (drop 1 items))
        message = (unwords (drop 2 items))

parseTimeStamp :: String -> TimeStamp
parseTimeStamp m = case i of
               ValidInt x -> x
               InvalidInt -> 0
               where i = readInt m

parseErrorLevel :: String -> Int
parseErrorLevel m = case i of
                     ValidInt x -> x
                     InvalidInt -> 0
                     where i = readInt m

validMessagesOnly :: [MaybeLogMessage] -> [LogMessage]
validMessagesOnly [] = []
validMessagesOnly (x:xs) = case x of
                             ValidLM lm -> lm : validMessagesOnly xs
                             InvalidLM _ -> validMessagesOnly xs

getLogLevel :: LogMessage -> TimeStamp
getLogLevel (LogMessage (Error x) _ _) = x
getLogLevel (LogMessage _ _ _) = 0

getTimeStamp :: LogMessage -> TimeStamp
getTimeStamp (LogMessage _ a _) = a

getMessage :: LogMessage -> String
getMessage (LogMessage _ _ a) = a

errorMessagesOnly :: [LogMessage] -> [LogMessage]
errorMessagesOnly [] = []
errorMessagesOnly (x:xs) = case x of
                             (LogMessage (Error _) _ _) -> x : errorMessagesOnly xs
                             _ -> errorMessagesOnly xs

hasLogLevelHigherThen50 :: LogMessage -> Bool
hasLogLevelHigherThen50 x = (getLogLevel x) >= 50

parse :: String -> [LogMessage]
parse f = validMessagesOnly (map parseMessage (lines f))

compareMsgs :: LogMessage -> LogMessage -> Ordering
compareMsgs x y = compare (getTimeStamp x) (getTimeStamp y)

sortMessages :: [LogMessage] -> [LogMessage]
sortMessages messages = sortBy compareMsgs messages

whatWentWrong :: [LogMessage] -> [String]
whatWentWrong messages = (map getMessage (filter hasLogLevelHigherThen50 (errorMessagesOnly messages)))

hasMessageMatching :: String -> LogMessage -> Bool
hasMessageMatching term x = term `isInfixOf` (getMessage x)

messagesAbout :: String -> [LogMessage] -> [LogMessage]
messagesAbout term messages = filter (hasMessageMatching term) messages

(|||) :: (LogMessage -> Bool) -> (LogMessage -> Bool) -> LogMessage -> Bool
(|||) f g x = f x || g x -- (||) is "or"

whatWentWrongEnhanced :: String -> [LogMessage] -> [String]
whatWentWrongEnhanced _ [] = []
whatWentWrongEnhanced term (x:xs)
    | (hasLogLevelHigherThen50 ||| (hasMessageMatching term)) x = (getMessage x) : whatWentWrongEnhanced term xs
    | otherwise = whatWentWrongEnhanced term xs