̵      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None-02346:=BHKM*2This has everything each log message will contain.(Log message with Builder unerneath; use  to concat in O(1).9Verbosity controls the amount of information (columns) a < emits during logging.The convention is: - F implies no additional payload information is included in message. - v implies the maximum amount of payload information. - Anything in between is left to the discretion of the developer.System is unusableTake immediate actionSevere situationsGeneral ErrorsGeneral WarningsNormal runtime Conditions Information Debug messages!Application environment, like prod, devel, testing.$Represents 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"].'<Ready namespace for emission with dots to join the segments.*"Pack any string-like thing into a #. This will automatically work on , 'ByteString,  and any of the lazy variants.+Shorthand for ,(Convert any showable type into a LogStr.:;Action to fetch the timestamp. You can use something like  AutoUpdatec for high volume logs but note that this may cause some output forms to display logs out of order.<gScribes are handlers of incoming items. Each registered scribe knows how to push a log item somewhere. Guidelines for writing your own <Scribes should always take a  and .Severity is used to *exclude log messages* that are < the provided Severity. For instance, if the user passes InfoS, DebugS items should be ignored. Katip provides the b utility for this.DVerbosity is used to select keys from the log item's payload. Each DT instance describes what keys should be retained for each Verbosity level. Use the `; utility for extracting the keys that should be permitted.ZThere is no built-in mechanism in katip for telling a scribe that its time to shut down.  merely drops it from the 4>. This means there are 2 ways to handle resources as a scribe: Pass in the resource when the scribe is created. Handle allocation and release of the resource elsewhere. This is what the Handle scribe does.BReturn a finalizing function that tells the scribe to shut down. katip-elasticsearch's  mkEsScribe returns a IO (Scribe, IO ()). The finalizer will flush any queued log messages and shut down gracefully before returning. This can be hooked into your application's shutdown routine to ensure you never miss any log messages on shutdown.D,Payload objects need instances of this class. LogItem makes it so that you can have very verbose items getting logged with lots of extra fields but under normal circumstances, if your scribe is configured for a lower verbosity level, it will only log a selection of those keys. Furthermore, each <% can be configured with a different  level. You could even use , , and d to at runtime swap out your existing scribes for more verbose debugging scribes if you wanted to.When defining E, don't redundantly declare the same keys for higher levels of verbosity. Each level of verbosity automatically and recursively contains all keys from the level before it.ECList of keys in the JSON object that should be included in message.FKatip requires JSON objects to be logged as context. This typeclass provides a default instance which uses ToJSON and produces an empty object if  results in any type other than object. If you have a type you want to log that produces an Array or Number for example, you'll want to write an explicit instance here. You can trivially add a ToObject instance for something with a ToJSON instance like: instance ToObject FooH0Field selector by verbosity within JSON payload._*Construct a simple log from any JSON item.`~Constrain payload based on verbosity. Backends should use this to automatically bubble higher verbosity levels to lower ones.aConvert log item to its JSON representation while trimming its payload based on the desired verbosity. Backends that push JSON messages should use this to obtain their payload.b=Should this item be logged given the user's maximum severity?g>A 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 .t4A concrete monad you can use to run logging actions.w3Monads where katip logging actions can be performed0Create a reasonable default InitLogEnv. Uses an  AutoUdate with the default settings as the timer. If you are concerned about timestamp precision or event ordering in log outputs like ElasticSearch, you should replace the timer with aAdd a scribe to the list. All future log calls will go to this scribe in addition to the others.Remove a scribe from the list. All future log calls will no longer use this scribe. If the given scribe doesn't exist, its a no-op.jUnregister *all* scribes. Logs will go off into space from this point onward until new scribes are added.Execute t on a log env.iLog with everything, including a source code location. This is very low level and you typically can use  in its place.5Log with full context, but without any code location.LPerform an action while logging any exceptions that may occur. Inspired by .-> logException () mempty ErrorS (error "foo");Log a message without any payload/context or code location.Lift a location into an Exp._For use when you want to include location in your logs. This will fill the 'Maybe Loc' gap in  of this module.,-tagged logging when using template-haskell. &$(logT) obj mempty InfoS "Hello world"  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%A base namespace for this applicationCurrent run environment (e.g. prod vs. devel)Name the scribeName of the scribeContextual payload for the log"Specific namespace of the message.Severity of the messageThe log message Log context NamespaceSeverityMain action being runu  !"#$%&'()*+,-456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abtuvwxyz{|}~$%&3'!"# ()210/.*+, - ]\[ZYXWVUTSsQRrqNOPpon^KLMmlHJIkFGjiDEhBC?@Agfed_`a<=>cb456789:;~}|{zywxtuva   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHJIKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None!"*02346=BHKM -Provides a simple transformer that defines a  instance for a fixed namespace and context. You will typically only use this if you are forced to run in IO but still want to have your log context. This is the slightly more powerful version of KatipT in that it provides KatipContext instead of just Katip. For instance:  threadWithLogging = do le <- getLogEnv ctx <- getKatipContext ns <- getKatipNamespace forkIO $ runKatipContextT le ctx ns $ do $(logTM) InfoS "Look, I can log in IO and retain context!" doOtherStuff A monadic context that has an inherant way to get logging context and namespace. Examples include a web application monad or database monad.:Heterogeneous list of log contexts that provides a smart  LogContext instance for combining multiple payload policies. This is critical for log contexts deep down in a stack to be able to inject their own context without worrying about other context that has already been set.A wrapper around a log context that erases type information so that contexts from multiple layers can be combined intelligently.bLift a log context into the generic wrapper so that it can combine with the existing log context.iLog with everything, including a source code location. This is very low level and you typically can use < in its place. Automaticallysupplies payload and namespace.dLog with full context, but without any code location. Automatically supplies payload and namespace.[-tagged logging when using template-haskell. Automatically supplies payload and namespace. $(logt) InfoS "Hello world"LPerform an action while logging any exceptions that may occur. Inspired by .$> error "foo" `logExceptionM` ErrorS*Severity of the messageThe log messageMain action to runSeverity None 036BHMColor if output is a terminal0Whether to use color control chars in log output8Logs to a file handle such as stdout, stderr, or a file.GAn implicit environment to enable logging directly ouf of the IO monad. None 036BHMs  !"#$%&()*+,456789:;<=>?DEFGHIJSTUVWXYZ[\]_`abtuvwxyz{|}~swx$%&!"# ()FGDE ST[\UZYW]XV HJI<=>456789:;z|{y~}?_tuv*+,b`a      !"##$%%&'()*+,-./01234456789:;;<==>??@ABCDEFGGHIIJKKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~ katip-0.1.1.0 Katip.Core Katip.MonadicKatip.Scribes.HandleKatipItem_itemApp_itemEnv _itemSeverity _itemThread _itemHost _itemProcess _itemPayload _itemMessage _itemTime_itemNamespace_itemLoc ThreadIdTextgetThreadIdTextLogStrunLogStr VerbosityV3V2V1V0Severity EmergencySAlertS CriticalSErrorSWarningSNoticeSInfoSDebugS EnvironmentgetEnvironment Namespace unNamespace intercalateNsrenderSeverity severityTextlogStrlsshowLSmkThreadIdText$fFromJSONLogStr$fMonoidLogStr$fIsStringLogStr$fFromJSONSeverity$fToJSONSeverity$fIsStringNamespaceLogEnv _logEnvHost _logEnvPid _logEnvNs _logEnvEnv _logEnvTimer_logEnvScribesScribeliPushSimpleLogPayloadunSimpleLogPayload AnyLogPayloadLogItem payloadKeysToObjecttoObjectPayloadSelectionSomeKeysAllKeys ProcessIDJsgetProcessIDJsLocJsgetLocJsLocShowitemAppitemEnvitemHostitemLoc itemMessage itemNamespace itemPayload itemProcess itemSeverity itemThreaditemTime processIDTextsl payloadObjectitemJson permitItem$fMonoidScribe$fMonoidSimpleLogPayload$fLogItemSimpleLogPayload$fToObjectSimpleLogPayload$fToJSONSimpleLogPayload $fLogItem()$fToObjectHashMap $fToObject()$fMonoidPayloadSelection$fFromJSONProcessIDJs$fToJSONProcessIDJs$fFromJSONItem$fFromJSONLocJs $fToJSONLocJs $fToJSONItem $fShowLocShow $fShowItemKatipTunKatipT getLogEnv logEnvEnv logEnvHostlogEnvNs logEnvPid logEnvScribes logEnvTimer initLogEnvregisterScribeunregisterScribe clearScribes runKatipTlogItemlogF logExceptionlogMsgliftLocgetLoclogTlocationToString$fLiftSeverity$fLiftVerbosity$fLiftNamespace$fMonadBaseControlbKatipT$fMonadTransControlKatipT $fKatipKatipT$fKatipResourceT$fKatipWriterT $fKatipStateT $fKatipMaybeT$fKatipExceptT$fKatipEitherT$fKatipReaderTKatipContextTState ltsLogEnv ltsContext ltsNamespace KatipContextTunKatipContextT KatipContextgetKatipContextgetKatipNamespace LogContexts AnyLogContext liftPayloadlogItemMlogFMlogTM logExceptionMrunKatipContextT ColorStrategyColorIfTerminalColorLogbracketsgetKeys renderPrimmkHandleScribe formatItem _ioLogEnvbase Data.Monoid<>GHC.BaseString text-1.2.2.0Data.Text.InternalTextaeson-0.11.0.0Data.Aeson.Types.ClasstoJSONMonoid time-1.4.2Data.Time.ClockgetCurrentTimeexceptions-0.8.2.1Control.Monad.Catch onExceptiontemplate-haskellLanguage.Haskell.TH.SyntaxLoc$fKatipContextKatipContextT$fKatipKatipContextT$fMonadReaderrKatipContextT $fMonadBaseControlbKatipContextT $fMonadTransControlKatipContextT$fKatipContextRWST$fKatipContextRWST0$fKatipContextWriterT$fKatipContextWriterT0$fKatipContextExceptT$fKatipContextStateT$fKatipContextStateT0$fKatipContextResourceT$fKatipContextReaderT$fKatipContextListT$fKatipContextEitherT$fKatipContextMaybeT$fKatipContextIdentityT$fLogItemLogContexts$fToObjectLogContexts$fToJSONLogContexts