IV7       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy z { | } ~       None!"05IfInternal type of log records.Set of .]Severity is level of log message importance. It uniquely determines which messages to print.Debug messages Information)Important (more than average) informationGeneral warningsGeneral errors/severe errors   of all s.  Returns the   of 2s of elements greater or equal to the given value. Returns   of s not less than . Returns   of s not less than . Returns   of s not less than .Returns   of s not less than .Returns   of s not less than . Excludes  from the   of s.     None !"05If!=Data structure similar to queue but pops out elements after " if # > $.%Class for objects that have size. Implementations can take size as amount of memory items take, as amount of items in container, etc.&Creates new memory queue.'Removes last element from !."jAdd new element at the beginning removing elements from the end until size become not greater than limit.(#Converts queue to list of messages.!)*+,%-.$#/&'"( !)*+,%-$#&'"( !)*+,%-.$#/&'"(None!"05IfLogger name to keep in context."Defined such that n1 is parent for  (n1 <> n2) (see  Nhttp://hackage.haskell.org/package/hslogger-1.2.10/docs/System-Log-Logger.htmlhslogger description). !" !"None!"0569;<=DIRf)pThis type class exists to remove boilerplate logging by adding the logger's name to the context in each module.(TODO: replace current methods with Lens?* Extract logger name from context+Change logger name in context,Set logger name in context.-#Change logger name to the given one)*+,-./0123456)*+,-)*+*+,- )*+*+,-./0123456None!"059;<=DIRf7Default implementation of WithNamedLogger.:Runs a 7 with specified initial .789:;<=>789:789:789:;<=>None!"05IfK-Performs given action on file if file exists.KKKK(c) Serokell, 2016GPL-3 (see the file LICENSE)Serokell <hi@serokell.io> experimental POSIX, GHCNone!"05If0EDefines pre- and post-printed characters for printing colorized text.1 Colorizes Text.01212012(c) Serokell, 2016GPL-3 (see the file LICENSE)Serokell <hi@serokell.io> experimental POSIX, GHCNone !"$05IfLUA LogFormatter is used to format log messages. Note that it is paramterized on the Handlery to allow the formatter to use information specific to the handler (an example of can be seen in the formatter used in )M<Returns the passed message as is, ie. no formatting is done.3 Replace some 4+ variables in a string with supplied valuesN3An extensible formatter that allows new substition  variables to be defined. Each variable has an associated IO action that is used to produce the string to substitute for the variable name. The predefined variables are the same as for P  excluding $time and $utcTime.OLike PW but allow the time format to be specified in the first parameter (this is passed to )PTakes a format string, and returns a formatter that may be used to format log messages. The format string may contain variables prefixed with a $-sign which will be replaced at runtime with corresponding values. The currently supported variables are:$msg - The actual log message $loggername - The name of the logger$prio$ - The priority level of the message$tid - The thread ID$pid* - Process ID (Not available on windows)$time - The current time$utcTime - The current time in UTC TimeQsFormats UTC time in next format: "%Y-%m-%d %H:%M:%S%Q %Z" but %Q part show only in centiseconds (always 2 digits).RGet the current time rounded to 10^n picoseconds. n = 3 rounds to the nearest nanosecond. n = 6 rounds to the nearest microsecond. n = 9 will round to the nearest millisecond. n = 12 will round to the nearest second. L0The LogHandler that the passed message came fromThe log message and priorityThe logger nameThe formatted log messageM3EA list of (variableName, action to get the replacement string) pairsText to perform substitution onResulting stringNOPQRST5 LMNOPQRST STQRLMPON LM3NOPQRST5$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone !"05:DIRf U\This is the base class for the various log handlers. They should all adhere to this class.V6Tag of handler. Is arbitrary. Made for identification.WSets the log level. handle% will drop items beneath this level.XGets the current level.Y@Set a log formatter to customize the log format for this Handler[AForces an event to be logged regardless of the configured level.\xRead back from logger (e.g. file), newest first. You specify the number of (newest) logging entries. Logger can return pure []5 if this behaviour can't be emulated or store buffer.]DCloses the logging system, causing it to close any open files, etc.^Tag identifying handlers.aMLogs an event if it meets the requirements given by the most recent call to W. UVWXYZ[\]^_`a U]VXW\YZ[^_`a ^_`UVWXYZ[\]aUVWXYZ[\]^_`a$Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone!"05AILT\ffPThe name of the root logger, which is always defined and present on the system.67The log tree. Initialize it with a default root logger.7XGiven a name, return all components of it, starting from the root. Example return value: >["", "MissingH", "System.Cmd.Utils", "System.Cmd.Utils.pOpen"]g9Log a message using the given logger at a given priority.iReturns the logger for the given name. If no logger with that name exists, creates new loggers and any necessary parent loggers, with no connected handlers.jReturns the root logger.8Handle a log request.kSets file prefix to 9.lAdd handler to d. Returns a new d.mRemove a handler from the dg. Handlers are removed in the reverse order they were added, so the following property holds for any U h: !removeHandler . addHandler h = id'If no handlers are associated with the d, it is returned unchanged.The root logger's default handler that writes every message to stderr can be removed by using this function before any handlers have been added to the root logger: /updateGlobalLogger rootLoggerName removeHandlernSet the  'Logger'\'Rs list of handlers to the list supplied. All existing handlers are removed first.oNReturns the "level" of the logger. Items beneath this level will be ignored.pSets the "level" of the d. Returns a new d object with the new level.qClears the "level" of the d2. It will now inherit the level of | its parent.rISet severities for given logger. By default parent's severities are used.sSet or clear severities.tcUpdates the global record for the given logger to take into account any changes you may have made.uHelps you make changes on the given logger. Takes a function that makes changes and writes those changes back to the global database. Here's an example from above ("s" is a U): _updateGlobalLogger "MyApp.BuggyComponent" (setLevel DEBUG . setHandlers [s])v1Allow graceful shutdown. Release all opened fileshandlersetc.w1Retrieves content of log file(s) given path (w/o  _lcFilePrefix2, as specified in your config). Example: there's  component.log+ in config, but this function will return '[component.log.122, component.log.123]5 if you want to. Content is file lines newest first.FYI: this function is implemented to avoid the following problem: log-warper holds open handles to files, so trying to open log file for read would result in  IOException.$d:;<=>?9@ABCDEFf67gName of the logger to useSeverity of this messageThe log text itselfhij8klmnopqrstu Logger nameFunction to callvwdfghijklmnopqrstuvwdghvijflmnopqrstukwd:;<=>?9@ABCDEFf67ghij8klmnopqrstuvw $Copyright (C) 2004-2011 John GoerzenBSD3$John Goerzen <jgoerzen@complete.org> provisionalportableNone !"05DIRfyA helper data type.?Default action which just prints to handle using given message.G^Creates custom write action and memory queue where write action updates memory queue as well.yCreate a stream log handler. Log messages sent to this handler will be sent to the stream used initially. Note that the ]c method will have no effect on stream handlers; it does not actually close the underlying stream.Create a file log handler. Log messages sent to this handler will be sent to the filename specified, which will be opened in Append mode. Calling ]$ on the handler will close the file.yz{|}~G yz{|}~ yz{|}~yz{|}~G (c) Serokell, 2016GPL-3 (see the file LICENSE)Serokell <hi@serokell.io> experimental POSIX, GHCNone !"05:ITf:Wrapper over file handler with additional rounding option.Path to the file to be handled.vRound timestamps to this power of 10 picoseconds. Just 3 would round to nanoseconds. Just 12 would round to seconds..Stores configuration for hierarchical loggers.!Logger configuration which keeps  and .+Rotation parameters for logger config. See .Severity for terminal H output. If Nothing along with  then Warning and greater excluding Error are used.Severity for terminal I output. If Nothing along with  then Error is used.RShow time for non-error messages. Note that error messages always have timestamp.Show ThreadId for current logging thread.)Specifies action for printing to console.0Defines how to transform logger names in config.Specifies directory for log files. This can be useful to avoid prefixes if you have a lot of loggers. Another use case: different logger directories on different platforms.Hierarchical tree of loggers. Parameters for logging rotation.max size of file in bytesnumber of files to keep[Useful lens combinator to be used for logging initialization. Usually should be used with .3Zooming into logger name with putting specific key./Checks if logger rotation parameters are valid.Setup  to specified severity inside .Setup  to specified severity inside .Setup  to J inside .Setup  to J inside .Setup lcConsoleOutput inside .5Adds sensible predefined set of parameters to logger.Setup  inside .Setup  inside  to optional prefix.Setup  inside  to specific prefix.This instances violates fromJSON . toJSON = identity@ rule but doesn't matter because it is used only for debugging.DKLM440KL M None!"05If Similar to y. But holds file N inside mutable variable (O) to be able to rotate loggers. Create rotation logging handler.PQ PQ (c) Serokell, 2016GPL-3 (see the file LICENSE)Serokell <hi@serokell.io> experimental POSIX, GHCNone!"05IfThis function initializes global logging system for terminal output. At high level, it sets severity which will be used by all loggers by default, sets default formatters and sets custom severity for given loggers (if any).>NOTE: you probably don't want to use this function. Consider  .On a lower level it does the following: 1. Removes default handler from root logger, sets two handlers such that: 1.1. All messages are printed to stdout(. 1.2. Moreover messages with at least Error severity are printed to stderrq. 2. Sets given Severity to root logger, so that it will be used by descendant loggers by default. 3. Applies  setSeverity/ to given loggers. It can be done later using  setSeverity directly. Show time?Show ThreadId? (c) Serokell, 2016GPL-3 (see the file LICENSE)Serokell <hi@serokell.io> experimental POSIX, GHCNone !"05AITfThis function traverses # initializing all subloggers with / and redirecting output in file handlers. See  for more details.*Parses logger config from given file path.FApplies given builder to parsed logger config and initializes logging. Initializes logging using given R; to logger configurations, runs the action with the given .-Default logging configuration with the given .Enabled flags: of the root logger is set to  ( and upper) for the given logger is set to   ( and upper)I is set to 'Any True' which means that time is shown in the log messages. is set to # which turns the console output on.Example defaultConfig "example"" will produce such configurations: arotation: null showTid: false showTime: true printOutput: true logTree: _ltSubloggers: example: _ltSubloggers: {} _ltSeverity: - Debug - Info - Notice - Warning - Error _ltFiles: [] _ltSeverity: - Warning - Error _ltFiles: [] termSeveritiesOut: null filePrefix: null termSeveritiesErr: null Set ups the logging with $ and runs the action with the given .Example7Here we can see very simple working example of logging: ghci> :{ ghci| launchSimpleLogging "app" $ do ghci| logDebug "Debug message" ghci| putStrLn "Usual printing" ghci| logInfo "Job's done!" ghci| :}{ [app:DEBUG] [2017-12-07 11:25:06.47 UTC] Debug message Usual printing [app:INFO] [2017-12-07 11:25:06.47 UTC] Job's done! STSTNone!"*0569;<=DIORTf JInstances of this class should explain how they add messages to their log.Type alias for constraints  and U>. It is a very common situation to use both of them together.Type alias for constraints  and )s. We need two different type classes to support more flexible interface but in practice we usually use them both. Shortcut for  to use according severity. Shortcut for  to use according severity. Shortcut for  to use according severity. Shortcut for  to use according severity. Shortcut for  to use according severity.BLogs message with specified severity using logger name in context.\It's very common situation when we need to write log messages inside functions that work in V.QTo do so we need to configure logger name each time inside work of this function. liftLogIO9 is the easiest way to deal with such kind of situations. Usage ExampleWe have some function clientStart :: HostName -> .. -> IO ClientComponentMap clientStart hostName .. = do ... forkIO $ routeIncoming endPoint msgs ... We need to log  messages in  routeIncoming& function. To do that we firstly need  clientStart to work in U clientStart :: (MonadIO m) => HostName -> .. -> m ClientComponentMap clientStart hostName .. = do ... liftIO $ forkIO $ routeIncoming endPoint msgs ... After we added some  into  routeIncoming  clientStart should now work in . Thus we can use  which is combination of U and -. Taking into consideration all above we get: clientStart :: WithLoggerIO m => HostName -> .. -> m ClientComponentMap clientStart hostName .. = do ... logName <- askLoggerName liftIO $ forkIO $ usingLoggerName logName $ routeIncoming endPoint msgs ... 0So, here we see how useful this function can be. clientStart :: WithLoggerIO m => HostName -> .. -> m ClientComponentMap clientStart hostName .. = do ... liftLogIO forkIO $ routeIncoming endPoint msgs ...  None !"05ITf#Logs exception's description with ' /Runs the action, if an exception is raised the  is executed.Example%Here is very simple example of usage  on IO functions: Omain :: IO () main = do buildAndSetupYamlLogging productionB "log-config.yaml" usingLoggerName "new-logger" runWithExceptionLog runWithExceptionLog :: (WithLoggerIO m, MonadCatch m) => m () runWithExceptionLog = catchLog @IOException (liftIO simpleIOfun) simpleIOfun :: IO () simpleIOfun = getLine >>= readFile >>= putStrLn and when run you will get:run-main-from-this-example> not-existing-filename.txti[new-logger:ERROR] [2017-12-01 13:07:33.21 UTC] asd: openFile: does not exist (No such file or directory)None!"*059;<=DIORTf Pure implementation of X type class. Instead of writing log messages into console it appends log messages into W log. It uses DList] for better performance, because messages can be added only at the end of log. But it uses unsafePerformIO so use with caution within IO.TODO: Should we use some  Data.Tree@-like structure to observe message only by chosen logger names?#Holds all required information for dispatchLoggerName function.-Return log of pure logging action as list of . Logs all  LogEvent'<s from given list. This function supposed to be used after . Logs all  LogEvent's from given list. Just like  but uses proper logger Name.4Performs actual logging once given action completes.-Return log of pure logging action as list of ), using logger name provided by context.  Similar to 0, but provides logger name from current context. Running the . gives us the pair of target and the list of s, wrapped in X from where using the fact that (,) is Y logging can be triggered.Example  newtype PureSmth a = ... deriving (MonadSmth, ...) instance MonadSmth m => MonadSmt (NamedLoggerName m) evalPureSmth :: PureSmth a -> a makeField :: MonadSmth m => Data -> m Field run :: (MonadIO m, WithLogger m) => m () run = do data <- getData -- field :: Field field <- launchNamedPureLog (pure . evalPureSmth) (makeField data) -- ^ logging happens here ...   Similar to   , but calls Z on passed function result.ExampleThe example from  , with usage of this function will look like:  newtype PureSmth a = ... deriving (MonadSmth, ...) instance MonadSmth m => MonadSmt (NamedLoggerName m) evalPureSmth :: PureSmth a -> a makeField :: MonadSmth m => Data -> m Field run :: (MonadIO m, WithLogger m) => m () run = do data <- getData -- field :: Field field <- launchNamedPureLogWith evalPureSmth $ makeField data -- ^ logging happens here ...   Similar to !, but using provided logger name. ZPerform pure-logging computation, log its events and return the result of the computation                  (c) Serokell, 2016GPL-3 (see the file LICENSE)Serokell <hi@serokell.io> experimental POSIX, GHCNone!"05If )*+,-789:Kdfghijklmnopqrstuvwyz{|}~    [ !"#$%&'()*+,-./01234556789:;<=>?@ABCDEFGHIJKLMNOPPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~po                         !"#$%&'()*+,-./012345.6789:;<=>?@ABCDEFG|HIJKKGLMNOPQ RSTUSTVWXY Z [ \S]^S_` a bScd e eSfgWXhijkSlmSlnSlop'log-warper-1.8.2-FyGeXQG3Y69ELs7sTvqxefSystem.Wlog.SeveritySystem.Wlog.LoggerNameSystem.Wlog.HasLoggerNameSystem.Wlog.LoggerNameBoxSystem.Wlog.FileUtilsSystem.Wlog.FormatterSystem.Wlog.LogHandlerSystem.Wlog.IOLoggerSystem.Wlog.LogHandler.SimpleSystem.Wlog.LoggerConfigSystem.Wlog.LogHandler.RollerSystem.Wlog.TerminalSystem.Wlog.LauncherSystem.Wlog.CanLogSystem.Wlog.ExceptionSystem.Wlog.PureLoggingSystem.Wlog.MemoryQueueSystem.Wlog.ColorSystem.Log.HandlerSyslogDate.Time.Format formatTime System.WlogRoller setupLoggingWarningDebugErrorSeverity LogRecordLR SeveritiesInfoNotice allSeverities severityPlus debugPlusinfoPlus noticePlus warningPlus errorPlus excludeError$fToJSONSeverity$fFromJSONSeverity $fEqSeverity $fOrdSeverity$fEnumSeverity$fBoundedSeverity$fShowSeverity$fReadSeverity$fGenericSeverity$fShowLogRecord LoggerName getLoggerName$fToJSONKeyLoggerName$fToJSONLoggerName$fBuildableLoggerName$fMonoidLoggerName$fSemigroupLoggerName$fShowLoggerName$fIsStringLoggerName$fEqLoggerName$fOrdLoggerName$fHashableLoggerName$fGenericLoggerName HasLoggerName askLoggerNamemodifyLoggerName setLoggerName withSublogger$fHasLoggerNameIdentity$fHasLoggerNameRWST$fHasLoggerNameRWST0$fHasLoggerNameContT$fHasLoggerNameExceptT$fHasLoggerNameWriterT$fHasLoggerNameStateT$fHasLoggerNameStateT0$fHasLoggerNameReaderT LoggerNameBoxloggerNameBoxEntryusingLoggerName$fHasLoggerNameLoggerNameBox$fMFunctorLoggerNameBox $fMonadBaseControlbLoggerNameBox$fMonadReaderrLoggerNameBox$fFunctorLoggerNameBox$fApplicativeLoggerNameBox$fMonadLoggerNameBox$fMonadIOLoggerNameBox$fMonadTransLoggerNameBox$fMonadBaseLoggerNameBox$fMonadThrowLoggerNameBox$fMonadCatchLoggerNameBox$fMonadMaskLoggerNameBox$fMonadErrorLoggerNameBox$fMonadStateLoggerNameBox$fMonadFixLoggerNameBox whenExist LogFormatter nullFormatter varFormattertfLogFormattersimpleLogFormatter centiUtcTimeFgetRoundedTimestdoutFormatterstdoutFormatterTimeRounded LogHandlergetTagsetLevelgetLevel setFormatter getFormatteremitreadBackclose LogHandlerTagHandlerFilelike HandlerOtherlogHandlerMessage$fShowLogHandlerTag$fEqLogHandlerTagLogger$fGenericLoggerrootLoggerNamelogMlogMCond getLogger getRootLogger setPrefix addHandler removeHandler setHandlers clearLevel setSeveritiessetSeveritiesMaybesaveGlobalLoggerupdateGlobalLoggerremoveAllHandlersretrieveLogContent$fGenericLogInternalStateGenericHandler severities formatterprivData writeFunc closeFuncreadBackBufferghTagdefaultHandleAction streamHandler fileHandler$fLogHandlerGenericHandler HandlerWrap _hwFilePath _hwRounding$fGenericHandlerWrap$fShowHandlerWrap LoggerTree _ltSubloggers_ltFiles _ltSeverity LoggerMap hwFilePath hwRounding$fGenericLoggerTree$fShowLoggerTree LoggerConfig _lcRotation_lcTermSeverityOut_lcTermSeverityErr _lcShowTime _lcShowTid_lcConsoleAction _lcMapper_lcLogsDirectory_lcTreeRotationParameters rpLogLimit rpKeepFilesltFiles ltSeverity ltSubloggers fromScratch zoomLoggerisValidRotation$fFromJSONRotationParameters$fToJSONRotationParameters$fBuildableRotationParameters$fFromJSONLoggerTree$fToJSONLoggerTree$fFromJSONHandlerWrap$fToJSONHandlerWrap$fMonoidLoggerTree$fSemigroupLoggerTree$fGenericRotationParameters$fShowRotationParameterslcConsoleActionlcLogsDirectorylcMapper lcRotation lcShowTid lcShowTimelcTermSeverityErrlcTermSeverityOutlcTreetermSeveritiesOutBtermSeveritiesErrB showTimeBshowTidBconsoleActionBcustomConsoleActionB productionBmapperB maybeLogsDirBlogsDirB$fToJSONLoggerConfig$fFromJSONLoggerConfig$fMonoidLoggerConfig$fSemigroupLoggerConfigInvalidRotation RollerHandler rhSeverities rhFormatter rhFileHandle rhWriteAction rhCloseAction rhFileNamelogIndexrotationFileHandler$fExceptionInvalidRotation$fLogHandlerRollerHandler$fShowInvalidRotation$fEqInvalidRotationinitTerminalLoggingparseLoggerConfigbuildAndSetupYamlLogginglaunchFromFile defaultConfiglaunchSimpleLoggingCanLogdispatchMessage WithLoggerIO WithLoggerlogDebuglogInfo logNotice logWarninglogError logMessage liftLogIO $fCanLogRWST $fCanLogRWST0$fCanLogExceptT$fCanLogStateT$fCanLogStateT0$fCanLogReaderT$fCanLogLoggerNameBox $fCanLogIO logExceptioncatchLogNamedPureLoggerrunNamedPureLogger PureLogger runPureLoggerLogEvent leLoggerName leSeverity leMessage runPureLogdispatchEvents logEvents launchPureLogrunNamedPureLoglaunchNamedPureLoglaunchNamedPureLogWithusingNamedPureLogger logPureAction$fMFunctorNamedPureLogger$fCanLogNamedPureLogger$fMonadTransNamedPureLogger$fMFunctorPureLogger$fCanLogPureLogger$fShowLogEvent$fFunctorPureLogger$fApplicativePureLogger$fMonadPureLogger$fMonadTransPureLogger$fMonadStatePureLogger$fMonadThrowPureLogger$fHasLoggerNamePureLogger$fFunctorNamedPureLogger$fApplicativeNamedPureLogger$fMonadNamedPureLogger$fMonadStateNamedPureLogger$fMonadThrowNamedPureLogger$fHasLoggerNameNamedPureLoggercontainers-0.5.7.1 Data.Set.BaseSet MemoryQueue pushFront mqMemSizemqLimitSizednewMemoryQueuepopLast queueToList_mqLimit _mqMemSize_mqQueuegetSize $fSizedTextmqQueuetable colorizercolorizerBuilder replaceVars-type-operators-0.1.0.4-8AYSNxfNBFr9pg9hN6TUpcControl.Type.Operator$createLogFormatterlogInternalStatecomponentsOfNamehandleLogInternalState_lLevel _lHandlers_lNameHandlerTliTreeliPrefixLogTree lHandlerslLevellNamecreateWriteFuncWrapperbaseGHC.IO.Handle.FDstdoutstderrghc-prim GHC.TypesTrue filterObjectparseSeverities nonLoggersGHC.IO.Handle.TypesHandleGHC.MVarMVarrollerReadback rollerWritingGHC.IOFilePath HandlerFabricControl.Monad.IO.ClassMonadIOIOtransformers-0.5.2.0 Control.Monad.Trans.State.StrictStateTGHC.BaseMonadFunctorpure