h&g_]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred"%&)*8;<>48katip2This has everything each log message will contain.katip)Log message with Builder underneath; use  to concat in O(1).katip9Verbosity controls the amount of information (columns) a s emits during logging.The convention is: -  implies no additional payload information is included in message. -  implies the maximum amount of payload information. - Anything in between is left to the discretion of the developer.katipDebug messageskatip InformationkatipNormal runtime ConditionskatipGeneral WarningskatipGeneral ErrorskatipSevere situationskatipTake immediate action katipSystem is unusable!katipApplication environment, like prod, devel, testing.$katipRepresents a heirarchy of namespaces going from general to specific. For instance: ["processname", "subsystem"]. Note that single-segment namespaces can be created using IsString/OverloadedStrings, so "foo" will result in Namespace ["foo"].(katipA built-in convenience log payload that won't log anything on , but will log everything in any other level of verbosity. Intended for easy in-line usage without having to define new log types.Construct using # and combine multiple tuples using  from .katipCombine two scribes. Publishes to the left scribe if the left would permit the item and to the right scribe if the right would permit the item. Finalizers are called in sequence from left to right.katip0Create a reasonable default InitLogEnv. Uses an  AutoUpdate which updates the timer every 1ms. If you need even more timestamp precision at the cost of performance, consider setting j with .katipAdd a scribe to the list. All future log calls will go to this scribe in addition to the others. Writes will be buffered per the ScribeSettings to prevent slow scribes from slowing down logging. Writes will be dropped if the buffer fills.katipA concrete monad you can use to run logging actions. Use this if you prefer an explicit monad transformer stack and adding layers as opposed to implementing  for your monad.katipMonads where katip logging actions can be performed. Katip is the most basic logging monad. You will typically use this directly if you either don't want to use namespaces/contexts heavily or if you want to pass in specific contexts and/or namespaces at each log site.2For something more powerful, look at the docs for  KatipContext, which keeps a namespace and merged context. You can write simple functions that add additional namespacing and merges additional context on the fly. was added to allow for lexically-scoped modifications of the log env that are reverted when the supplied monad completes. ;, for example, uses this to temporarily pause log outputs.katip7Reasonable defaults for a scribe. Buffer size of 4096.katip0Remove a scribe from the environment. This does not finalize the scribe. This mainly only makes sense to use with something like MonadReader's local function to temporarily disavow a single logger for a block of code.katip Unregister all scribes. Note that this is not) for closing or finalizing scribes, use  for that. This mainly only makes sense to use with something like MonadReader's local function to temporarily disavow any loggers for a block of code.katipFinalize a scribe. The scribe is removed from the environment, its finalizer is called so that it can never be written to again and all pending writes are flushed. Note that this will throw any exceptions yoru finalizer will throw, and that LogEnv is immutable, so it will not be removed in that case.katipCall this at the end of your program. This is a blocking call that stop writing to a scribe's queue, waits for the queue to empty, finalizes each scribe in the log environment and then removes it. Finalizers are all run even if one of them throws, but the exception will be re-thrown at the end.katipExecute  on a log env.katipDisable all scribes for the given monadic action, then restore them afterwards. Works in any Katip monad.katipLog with everything, including a source code location. This is very low level and you typically can use  in its place.katipLog already constructed . This is the lowest level function that other log* functions use. It can be useful when implementing centralised logging services.katip5Log with full context, but without any code location.katipPerform an action while logging any exceptions that may occur. Inspired by .-> logException () mempty ErrorS (error "foo")katip;Log a message without any payload/context or code location.katipLift a location into an Exp.katipFor use when you want to include location in your logs. This will fill the 'Maybe Loc' gap in  of this module, and relies on implicit callstacks when available (GHC > 7.8).katip,-tagged logging when using template-haskell. &$(logT) obj mempty InfoS "Hello world"katip-tagged logging using  when available.This function does not require template-haskell as it automatically uses  https://hackage.haskell.org/package/base-4.8.2.0/docs/GHC-Stack.html#v:getCallStackimplicit-callstacks when the code is compiled using GHC > 7.8. Using an older version of the compiler will result in the emission of a log line without any location information, so be aware of it. Users using GHC <= 7.8 may want to use the template-haskell function  for maximum compatibility. %logLoc obj mempty InfoS "Hello world"katip%A base namespace for this applicationkatipCurrent run environment (e.g. prod vs. devel)katipName the scribekatipName of the scribekatipName of the scribekatip Did we write?katipContextual payload for the logkatip"Specific namespace of the message.katipSeverity of the messagekatipThe log messagekatip Log contextkatip NamespacekatipSeveritykatipMain action being run   !#"$&%'()*+,-.dkjihgfelnmorqpswvutxy{z|}~'$&%(!#" )*+,- . ~|}y{zxswvutorqplnmdkjihgfe Safe-Inferred "%&;9katipFormat $ into a short human readable format.formatAsLogTime $ UTCTime (fromGregorian 2016 1 23) 5025.123456789012"2016-01-23 01:23:45"katipFormat  into a Iso8601 format.Note that this function may overcommit up to 12*2 bytes, depending on sub-second precision. If this is an issue, make a copy with a .formatAsIso8601 $ UTCTime (fromGregorian 2016 1 23) 5025.123456789012#"2016-11-23T01:23:45.123456789012Z", so bear that in mind. The reasoning is that if the user is  sequentially adding contexts to the right side of the sequence, on conflict the intent is to overwrite with the newer value (i.e. the rightmost value).Additional note: you should not mappend LogContexts in any sort of infinite loop, as it retains all data, so that would be a memory leak.katipA wrapper around a log context that erases type information so that contexts from multiple layers can be combined intelligently.katipLift a log context into the generic wrapper so that it can combine with the existing log context.katipLog with everything, including a source code location. This is very low level and you typically can use = in its place. Automatically supplies payload and namespace.katipLog with full context, but without any code location. Automatically supplies payload and namespace.katip-tagged logging when using template-haskell. Automatically supplies payload and namespace. $(logTM) InfoS "Hello world"katip-tagged logging when using  implicit-callstacks>. Automatically supplies payload and namespace.Same consideration as  applies.By default, location will be logged from the module that invokes . If you want to use ) in a helper, wrap the entire helper in 2 to retain the callsite of the helper in the logs.This function does not require template-haskell. Using GHC <= 7.8 will result in the emission of a log line without any location information. Users using GHC <= 7.8 may want to use the template-haskell function  for maximum compatibility. logLocM InfoS "Hello world"katipPerform an action while logging any exceptions that may occur. Inspired by .$> error "foo" `logExceptionM` ErrorSkatipAppend a namespace segment to the current namespace for the given monadic action, then restore the previous state afterwards. Works with anything implementing KatipContext.katipAppend some context to the current context for the given monadic action, then restore the previous state afterwards. Important note: be careful using this in a loop. If you're using something like  or  that does explicit sharing to avoid a memory leak, youll be fine as it will *sequence* calls to , so each loop will get the same context added. If you instead roll your own recursion and you're recursing in the action you provide, you'll instead accumulate tons of redundant contexts and even if they all merge on log, they are stored in a sequence and will leak memory. Works with anything implementing KatipContext.katipConvenience function for when you have to integrate with a third party API that takes a generic logging function as an argument.katipSeverity of the messagekatipThe log messagekatipMain action to runkatipSeverity Safe-Inferred "%&;]% katip#A custom ItemFormatter for logging  s. Takes a - indicating whether to colorize the output,  of output, and an  to format.See  and  for examples.katip0Whether to use color control chars in log outputkatipColor if output is a terminalkatipLogs to a file handle such as stdout, stderr, or a file. Contexts and other information will be flattened out into bracketed fields. For example: [2016-05-11 21:01:15][MyApp][Info][myhost.example.com][PID 1724][ThreadId 1154][main:Helpers.Logging Helpers/Logging.hs:32:7] Started [2016-05-11 21:01:15][MyApp.confrabulation][Debug][myhost.example.com][PID 1724][ThreadId 1154][confrab_factor:42.0][main:Helpers.Logging Helpers/Logging.hs:41:9] Confrabulating widgets, with extra namespace and context [2016-05-11 21:01:15][MyApp][Info][myhost.example.com][PID 1724][ThreadId 1154][main:Helpers.Logging Helpers/Logging.hs:43:7] Namespace and context are back to normalReturns the newly-created s;. The finalizer flushes the handle. Handle mode is set to  automatically.katipLogs to a file handle such as stdout, stderr, or a file. Takes a custom  that can be used to format  as needed.Returns the newly-created s;. The finalizer flushes the handle. Handle mode is set to  automatically.katipA specialization of  that takes a  instead of a -. It is responsible for opening the file in $ and will close the file handle on /,. Does not do log coloring. Sets handle to  mode.katipA traditional  bracketed log format. Contexts and other information will be flattened out into bracketed fields. For example: [2016-05-11 21:01:15][MyApp][Info][myhost.example.com][PID 1724][ThreadId 1154][main:Helpers.Logging Helpers/Logging.hs:32:7] Started [2016-05-11 21:01:15][MyApp.confrabulation][Debug][myhost.example.com][PID 1724][ThreadId 1154][confrab_factor:42.0][main:Helpers.Logging Helpers/Logging.hs:41:9] Confrabulating widgets, with extra namespace and context [2016-05-11 21:01:15][MyApp][Info][myhost.example.com][PID 1724][ThreadId 1154][main:Helpers.Logging Helpers/Logging.hs:43:7] Namespace and context are back to normalkatipLogs items as JSON. This can be useful in circumstances where you already have infrastructure that is expecting JSON to be logged to a standard stream or file. For example: {"at":"2018-10-02T21:50:30.4523848Z","env":"production","ns":["MyApp"],"data":{},"app":["MyApp"],"msg":"Started","pid":"10456","loc":{"loc_col":9,"loc_pkg":"main","loc_mod":"Helpers.Logging","loc_fn":"Helpers\\Logging.hs","loc_ln":44},"host":"myhost.example.com","sev":"Info","thread":"ThreadId 139"} {"at":"2018-10-02T21:50:30.4523848Z","env":"production","ns":["MyApp","confrabulation"],"data":{"confrab_factor":42},"app":["MyApp"],"msg":"Confrabulating widgets, with extra namespace and context","pid":"10456","loc":{"loc_col":11,"loc_pkg":"main","loc_mod":"Helpers.Logging","loc_fn":"Helpers\\Logging.hs","loc_ln":53},"host":"myhost.example.com","sev":"Debug","thread":"ThreadId 139"} {"at":"2018-10-02T21:50:30.4523848Z","env":"production","ns":["MyApp"],"data":{},"app":["MyApp"],"msg":"Namespace and context are back to normal","pid":"10456","loc":{"loc_col":9,"loc_pkg":"main","loc_mod":"Helpers.Logging","loc_fn":"Helpers\\Logging.hs","loc_ln":55},"host":"myhost.example.com","sev":"Info","thread":"ThreadId 139"}katipColor a text message based on . * and more severe errors are colored red,  is colored yellow, and all other messages are rendered in the default color.katipProvides a simple log environment with 1 scribe going to stdout. This is a decent example of how to build a LogEnv and is best for scripts that just need a quick, reasonable set up to log to stdout.  Safe-Inferred "%&;]  !"#$%&)*+,-defghijkstuvwxy~$%&!"# )*~ stuvwdefghijky+,-x      !"#$%&'(()**+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrsstuvvwxyz{{|}}~ $katip-0.8.7.4-JHmBy48YxwsLMeC16HcJiy Katip.CoreKatip.Format.Time Katip.MonadicKatip.Scribes.HandleGHCStack Data.TextcopyKatipItem_itemApp_itemEnv _itemSeverity _itemThread _itemHost _itemProcess _itemPayload _itemMessage _itemTime_itemNamespace_itemLoc ThreadIdTextgetThreadIdTextLogStrunLogStr VerbosityV0V1V2V3SeverityDebugSInfoSNoticeSWarningSErrorS CriticalSAlertS EmergencyS EnvironmentgetEnvironment Namespace unNamespacereadMay intercalateNsrenderSeveritytextToSeveritylogStrlsshowLSmkThreadIdText$fIsStringNamespace$fFromJSONSeverity$fToJSONSeverity$fFromJSONVerbosity$fToJSONVerbosity$fFromJSONLogStr$fMonoidLogStr$fSemigroupLogStr$fIsStringLogStr $fGenericItem $fFunctorItem$fToJSONThreadIdText$fFromJSONThreadIdText$fShowThreadIdText$fEqThreadIdText$fOrdThreadIdText$fGenericLogStr $fShowLogStr $fEqLogStr $fEqVerbosity$fOrdVerbosity$fShowVerbosity$fReadVerbosity$fGenericVerbosity$fEnumVerbosity$fBoundedVerbosity$fLiftBoxedRepVerbosity $fEqSeverity $fOrdSeverity$fShowSeverity$fReadSeverity$fGenericSeverity$fEnumSeverity$fBoundedSeverity$fLiftBoxedRepSeverity$fEqEnvironment$fShowEnvironment$fReadEnvironment$fOrdEnvironment$fGenericEnvironment$fToJSONEnvironment$fFromJSONEnvironment$fIsStringEnvironment $fEqNamespace$fShowNamespace$fReadNamespace$fOrdNamespace$fGenericNamespace$fToJSONNamespace$fFromJSONNamespace$fSemigroupNamespace$fMonoidNamespace$fLiftBoxedRepNamespaceLogEnv _logEnvHost _logEnvPid _logEnvApp _logEnvEnv _logEnvTimer_logEnvScribes WorkerMessageNewItem PoisonPill ScribeHandleshScribeshChanScribeliPushscribeFinalizerscribePermitItem PermitFuncSimpleLogPayloadunSimpleLogPayload AnyLogPayloadLogItem payloadKeysToObjecttoObjectPayloadSelectionAllKeysSomeKeys ProcessIDJsgetProcessIDJsLocJsgetLocJsLocShowitemAppitemEnvitemHostitemLoc itemMessage itemNamespace itemPayload itemProcess itemSeverity itemThreaditemTimeprocessIDToTexttextToProcessIDequivalentPayloadSelectiontoKeysl payloadObject filterElemsitemJson permitANDpermitORwhenM permitItem$fEqItem $fShowLocShow $fShowItem$fFromJSONLocJs $fToJSONLocJs$fFromJSONProcessIDJs$fToJSONProcessIDJs$fFromJSONItem $fToJSONItem$fMonoidPayloadSelection$fSemigroupPayloadSelection$fToObjectKeyMap $fToObject() $fLogItem()$fMonoidSimpleLogPayload$fSemigroupSimpleLogPayload$fLogItemSimpleLogPayload$fToObjectSimpleLogPayload$fToJSONSimpleLogPayload$fMonoidScribe$fSemigroupScribe$fShowPayloadSelection$fEqPayloadSelectionScribeSettings_scribeBufferSize logEnvApp logEnvEnv logEnvHost logEnvPid logEnvScribes logEnvTimer initLogEnvregisterScribespawnScribeWorker$fShowScribeSettings$fEqScribeSettingsKatipTunKatipT getLogEnv localLogEnvscribeBufferSizedefaultScribeSettingsunregisterScribe clearScribes closeScribe closeScribes runKatipTkatipNoLogginglogItem logKatipItemtryWriteTBQueuelogF logExceptionlogMsgliftLocgetLocgetLocTHlogTlogLoclocationToString$fKatipResourceT$fKatipWriterT$fKatipWriterT0 $fKatipStateT $fKatipRWST $fKatipRWST0$fKatipStateT0 $fKatipMaybeT$fKatipExceptT$fKatipReaderT$fMonadFailKatipT$fMonadUnliftIOKatipT$fMonadBaseControlbKatipT$fMonadTransControlKatipT $fKatipKatipT$fFunctorKatipT$fApplicativeKatipT $fMonadKatipT$fMonadIOKatipT$fMonadMaskKatipT$fMonadCatchKatipT$fMonadThrowKatipT$fMonadResourceKatipT$fMonadTransKatipT$fMonadBasebKatipTformatAsLogTimeformatAsIso8601 NoLoggingT runNoLoggingTKatipContextTState ltsLogEnv ltsContext ltsNamespace KatipContextTunKatipContextT KatipContextgetKatipContextlocalKatipContextgetKatipNamespacelocalKatipNamespace LogContexts AnyLogContext liftPayloadlogItemMlogFMlogTMlogLocM logExceptionMrunKatipContextTkatipAddNamespacekatipAddContext askLoggerIO$fLogItemLogContexts$fToObjectLogContexts$fToJSONLogContexts$fKatipContextRWST$fKatipContextRWST0$fKatipContextWriterT$fKatipContextWriterT0$fKatipContextExceptT$fKatipContextStateT$fKatipContextStateT0$fKatipContextResourceT$fKatipContextReaderT$fKatipContextMaybeT$fKatipContextIdentityT$fMonadFailKatipContextT$fMonadUnliftIOKatipContextT$fKatipContextKatipContextT$fKatipKatipContextT$fMonadReaderrKatipContextT $fMonadBaseControlbKatipContextT $fMonadTransControlKatipContextT$fKatipContextNoLoggingT$fKatipNoLoggingT$fMonadUnliftIONoLoggingT$fMonadBaseControlbNoLoggingT$fMonadTransControlNoLoggingT$fMonadTransNoLoggingT$fFunctorNoLoggingT$fApplicativeNoLoggingT$fMonadNoLoggingT$fMonadIONoLoggingT$fMonadThrowNoLoggingT$fMonadCatchNoLoggingT$fMonadMaskNoLoggingT$fMonadBasebNoLoggingT$fMonadStatesNoLoggingT$fMonadWriterwNoLoggingT$fMonadErroreNoLoggingT$fMonadPlusNoLoggingT$fAlternativeNoLoggingT$fMonadFixNoLoggingT$fMonadReaderrNoLoggingT$fFunctorKatipContextT$fApplicativeKatipContextT$fMonadKatipContextT$fMonadIOKatipContextT$fMonadThrowKatipContextT$fMonadCatchKatipContextT$fMonadMaskKatipContextT$fMonadBasebKatipContextT$fMonadStatesKatipContextT$fMonadWriterwKatipContextT$fMonadErroreKatipContextT$fMonadPlusKatipContextT$fMonadResourceKatipContextT$fAlternativeKatipContextT$fMonadFixKatipContextT$fMonadTransKatipContextT$fMonoidLogContexts$fSemigroupLogContexts$fKatipContextKatipT ItemFormatter ColorStrategyColorLogColorIfTerminalbracketsgetKeys toBuilders toTxtKeyList renderPairmkHandleScribemkHandleScribeWithFormatter mkFileScribe formatItem bracketFormat jsonFormatcolorBySeverityioLogEnv$fShowColorStrategy$fEqColorStrategybaseGHC.Base<>String text-1.2.5.0Data.Text.InternalText time-1.11.1.1Data.Time.Clock.POSIXgetCurrentTime$aeson-2.1.2.1-DMrrVhsiNy4H2FC7pKm8YdData.Aeson.Types.ToJSONtoJSONMonoid.safe-exceptions-0.1.7.3-F3pCGsFacJi7W8pk2HTFeyControl.Exception.Safe onExceptiontemplate-haskellLanguage.Haskell.TH.SyntaxLoc Data.Time.Clock.Internal.UTCTimeUTCTimewriteDaywriteTimeOfDayGHC.Stack.Types getCallStack GHC.StackwithFrozenCallStack Control.Monadforever replicateM_Data.Aeson.Types.InternalValueGHC.IO.Handle.Types LineBufferingGHC.IOFilePathHandle GHC.IO.IOMode AppendMode