%08      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./01234567None !"5:<=IOTFormat 8$ into a short human readable format.EformatAsLogTime $ UTCTime (fromGregorian 2016 1 23) 5025.123456789012"2016-01-23 01:23:45"Format 8 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 .EformatAsIso8601 $ UTCTime (fromGregorian 2016 1 23) 5025.123456789012#"2016-11-23T01:23:45.123456789012Z"<formatAsIso8601 $ UTCTime (fromGregorian 2016 1 23) 5025.123"2016-01-23T01:23:45.123Z"8formatAsIso8601 $ UTCTime (fromGregorian 2016 1 23) 5025"2016-01-23T01:23:45Z"9 Writes the  YYYY-MM-DD part of timestamp:.Write time of day, optionally with sub seconds;<=>9:?@ABCDEF;<=>9:?@ABCDEFNone!"%&2569:;<=ADIORT12This has everything each log message will contain.)Log message with Builder underneath; use G to concat in O(1).9Verbosity controls the amount of information (columns) a o 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.Debug messages InformationNormal runtime ConditionsGeneral WarningsGeneral Errors Severe situations!Take immediate action"System is unusable#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 H,  ByteString, I and any of the lazy variants..Shorthand for -/!Convert any showable type into a .dName of application. This will typically never change. This field gets prepended to the namespace of your individual log messages. For example, if your app is MyApp and you write a log using "logItem" and the namespace  WebServer, the final namespace will be MyApp.WebServerf;Action to fetch the timestamp. You can use something like  AutoUpdate for high volume logs but note that this may cause some output forms to display logs out of order. Alternatively, you could just use J.ogScribes are handlers of incoming items. Each registered scribe knows how to push a log item somewhere. Guidelines for writing your own oScribes 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  utility for this.DVerbosity is used to select keys from the log item's payload. Each xT 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 `>. 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 an 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.rProvide a *blocking* finalizer to call when your scribe is removed. If this is not relevant to your scribe, return () is fine.x,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 o% 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 y, 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.yCList of keys in the JSON object that should be included in message.zKatip requires JSON objects to be logged as context. This typeclass provides a default instance which uses ToJSON and produces an empty object if K 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 Foo|0Field 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.Convert 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.=Should this item be logged given the user's maximum severity?>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 G from L.0Create 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 JaAdd a scribe to the list. All future log calls will go to this scribe in addition to the others.A 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.Monads 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.7Reasonable defaults for a scribe. Buffer size of 4096.Remove a scribe from the environment. This does *not* finalize the scribe. This mainly only makes sense to use with something like MonadReader's localF function to temporarily disavow a single logger for a block of code.ZUnregister *all* scribes. Note that this is *not* for closing or finalizing scribes, use R for that. This mainly only makes sense to use with something like MonadReader's localB function to temporarily disavow any loggers for a block of code. Finalize a scribe. The scribe is removed from the environment, its finalizer is called and it can never be written to again. 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.+Call 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.Execute  on a log env.jDisable all scribes for the given monadic action, then restore them afterwards. Works in any Katip monad.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 M.-> 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 O of this module, and relies on implicit callstacks when available (GHC > 7.8).N,-tagged logging when using template-haskell. &$(logT) obj mempty InfoS "Hello world"N9-tagged logging using implicit-callstacks when available.JThis function does not require template-haskell as it automatically uses  Shttps://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"  !"#$%&'()*+,-./01234567`abcdefghijklmnopqrstuvwxyz{|}~%A base namespace for this applicationCurrent run environment (e.g. prod vs. devel)Name the scribeName of the scribeName of the scribe Did we write?Contextual payload for the log"Specific namespace of the message.Severity of the messageThe log message Log context NamespaceSeverityMain action being run  !"#$%&'()*+,-./0`abcdefghijklmnopqrstuvwxyz{|}~չ)&'(7*#$% !"+,654321-./0 |}~z{{xyvwstuopqrklmnhij`abcdefgw   !"#$%&'()*+,-./01234567`abcdefghijklmnopqrstuvwxyz{{|}~None!"%&/59:;<=DIORT-Provides a simple transformer that defines a 8 instance for a fixed namespace and context. Just like i, you should use this if you prefer an explicit transformer stack and don't want to (or cannot) define  for your monad . 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. The local variants are just like local< from Reader and indeed you can easily implement them with localB if you happen to be using a Reader in your monad. These give us  and  that works with *any* Z, as opposed to making users have to implement these functions on their own in each app.XTemporarily modify the current context for the duration of the supplied monad. Used in ZTemporarily modify the current namespace for the duration of the supplied monad. Used in :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. Also note that contexts are treated as a sequence and G will be appended to the right hand side of the sequence. If there are conflicting keys in the contexts, the /right side will take precedence/, which is counter to how monoid works for Map and HashMap>, 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.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. Automatically supplies payload and namespace.dLog with full context, but without any code location. Automatically supplies payload and namespace.N[-tagged logging when using template-haskell. Automatically supplies payload and namespace. $(logTM) InfoS "Hello world"N[-tagged logging when using template-haskell. Automatically supplies payload and namespace.Same consideration as  applies.JThis function does not require template-haskell as it automatically uses  Shttps://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. logLocM InfoS "Hello world"LPerform an action while logging any exceptions that may occur. Inspired by M.$> error "foo" `logExceptionM` ErrorSAppend a namespace segment to the current namespace for the given monadic action, then restore the previous state afterwards. Works with anything implementing KatipContext.Append 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 O or Pc that does explicit sharing to avoid a memory leak, youll be fine as it will *sequence* calls to F, 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..QRSeverity of the messageThe log messageMain action to runSeverity     "QR     None !"5:<=IOT.0Whether to use color control chars in log output/Color if output is a terminal2Logs 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][1724][ThreadId 1154][main:Helpers.Logging Helpers/Logging.hs:32:7] Started [2016-05-11 21:01:15][MyApp.confrabulation][Debug][myhost.example.com][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][1724][ThreadId 1154][main:Helpers.Logging Helpers/Logging.hs:43:7] Namespace and context are back to normalReturns the newly-created o;. The finalizer flushes the handle. Handle mode is set to S automatically.3A specialization of 2 that takes a T instead of a U-. It is responsible for opening the file in V$ and will close the file handle on 'closeScribe'/'closeScribes',. Does not do log coloring. Sets handle to S mode.5Provides 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. -./012345 -./012345 01-./2345-./012345None !"5:<=IOT  !"#$%&'(+,-./`abcdefgopqrsxyz{|}~-./23&'(#$% !"+,z{{xy |}~opqr`abcdefgs-./23-./W       !"#$%&'(()**+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abccdefghijklmmnoppqrsstuuvwxyz{|}}~      !"#$%&'()*+,-./01234556789:;<=>?@>ABCDE.FGHIJ>AKLMNOPQ>RS>RT>UV>WX>UY>Z[\$katip-0.5.2.0-3Sy7A5XTsZiKL1dVIPMWL5Katip.Format.Time Katip.Core Katip.MonadicKatip.Scribes.Handle Data.TextcopyKatipformatAsLogTimeformatAsIso8601Item_itemApp_itemEnv _itemSeverity _itemThread _itemHost _itemProcess _itemPayload _itemMessage _itemTime_itemNamespace_itemLoc ThreadIdTextgetThreadIdTextLogStrunLogStr VerbosityV0V1V2V3SeverityDebugSInfoSNoticeSWarningSErrorS CriticalSAlertS EmergencyS EnvironmentgetEnvironment Namespace unNamespacereadMay intercalateNsrenderSeveritytextToSeveritylogStrlsshowLSmkThreadIdText$fFromJSONLogStr$fMonoidLogStr$fSemigroupLogStr$fIsStringLogStr$fFromJSONSeverity$fToJSONSeverity$fIsStringNamespace $fEqNamespace$fShowNamespace$fReadNamespace$fOrdNamespace$fGenericNamespace$fToJSONNamespace$fFromJSONNamespace$fSemigroupNamespace$fMonoidNamespace$fEqEnvironment$fShowEnvironment$fReadEnvironment$fOrdEnvironment$fGenericEnvironment$fToJSONEnvironment$fFromJSONEnvironment$fIsStringEnvironment $fEqSeverity $fOrdSeverity$fShowSeverity$fReadSeverity$fGenericSeverity$fEnumSeverity$fBoundedSeverity $fEqVerbosity$fOrdVerbosity$fShowVerbosity$fReadVerbosity$fGenericVerbosity$fEnumVerbosity$fGenericLogStr $fShowLogStr $fEqLogStr$fToJSONThreadIdText$fFromJSONThreadIdText$fShowThreadIdText$fEqThreadIdText$fOrdThreadIdText $fGenericItem $fFunctorItemLogEnv _logEnvHost _logEnvPid _logEnvApp _logEnvEnv _logEnvTimer_logEnvScribes WorkerMessageNewItem PoisonPill ScribeHandleshScribeshChanScribeliPushscribeFinalizerSimpleLogPayloadunSimpleLogPayload AnyLogPayloadLogItem payloadKeysToObjecttoObjectPayloadSelectionAllKeysSomeKeys ProcessIDJsgetProcessIDJsLocJsgetLocJsLocShowitemAppitemEnvitemHostitemLoc itemMessage itemNamespace itemPayload itemProcess itemSeverity itemThreaditemTimeprocessIDToTexttextToProcessIDsl payloadObjectitemJson permitItem$fMonoidScribe$fSemigroupScribe$fMonoidSimpleLogPayload$fSemigroupSimpleLogPayload$fLogItemSimpleLogPayload$fToObjectSimpleLogPayload$fToJSONSimpleLogPayload $fLogItem()$fToObjectHashMap $fToObject()$fMonoidPayloadSelection$fSemigroupPayloadSelection$fFromJSONProcessIDJs$fToJSONProcessIDJs$fFromJSONItem$fFromJSONLocJs $fToJSONLocJs $fToJSONItem $fShowLocShow $fShowItem$fEqItem$fShowPayloadSelection$fEqPayloadSelectionScribeSettings_scribeBufferSize logEnvApp logEnvEnv logEnvHost logEnvPid logEnvScribes logEnvTimer initLogEnvregisterScribespawnScribeWorker$fShowScribeSettings$fEqScribeSettingsKatipTunKatipT getLogEnv localLogEnvscribeBufferSizedefaultScribeSettingsunregisterScribe clearScribes closeScribe closeScribes runKatipTkatipNoLogginglogItemtryWriteTBQueuelogF logExceptionlogMsgliftLocgetLocgetLocTHlogTlogLoclocationToString$fLiftSeverity$fLiftVerbosity$fLiftNamespace$fMonadBaseControlbKatipT$fMonadTransControlKatipT $fKatipKatipT$fKatipResourceT$fKatipWriterT$fKatipWriterT0 $fKatipStateT $fKatipRWST $fKatipRWST0$fKatipStateT0 $fKatipMaybeT$fKatipExceptT$fKatipReaderT$fFunctorKatipT$fApplicativeKatipT $fMonadKatipT$fMonadIOKatipT$fMonadMaskKatipT$fMonadCatchKatipT$fMonadThrowKatipT$fMonadTransKatipT$fMonadBaseKatipTKatipContextTState ltsLogEnv ltsContext ltsNamespace KatipContextTunKatipContextT KatipContextgetKatipContextlocalKatipContextgetKatipNamespacelocalKatipNamespace LogContexts AnyLogContext liftPayloadlogItemMlogFMlogTMlogLocM logExceptionMrunKatipContextTkatipAddNamespacekatipAddContext$fKatipContextKatipContextT$fKatipKatipContextT$fMonadReaderrKatipContextT $fMonadBaseControlbKatipContextT $fMonadTransControlKatipContextT$fKatipContextRWST$fKatipContextRWST0$fKatipContextWriterT$fKatipContextWriterT0$fKatipContextExceptT$fKatipContextStateT$fKatipContextStateT0$fKatipContextResourceT$fKatipContextReaderT$fKatipContextListT$fKatipContextMaybeT$fKatipContextIdentityT$fLogItemLogContexts$fToObjectLogContexts$fToJSONLogContexts$fMonoidLogContexts$fSemigroupLogContexts$fFunctorKatipContextT$fApplicativeKatipContextT$fMonadKatipContextT$fMonadIOKatipContextT$fMonadThrowKatipContextT$fMonadCatchKatipContextT$fMonadMaskKatipContextT$fMonadBaseKatipContextT$fMonadStateKatipContextT$fMonadWriterKatipContextT$fMonadErrorKatipContextT$fMonadPlusKatipContextT$fAlternativeKatipContextT$fMonadFixKatipContextT$fMonadTransKatipContextT$fKatipContextKatipT ColorStrategyColorLogColorIfTerminalbracketsgetKeysmkHandleScribe mkFileScribe formatItemioLogEnv$fShowColorStrategy$fEqColorStrategy time-1.6.0.1Data.Time.Clock.UTCUTCTimewriteDaywriteTimeOfDay TimeOfDay64TODTwriteFracSeconds writeDigit6 writeDigit3 writeTrunc6 writeTrunc3 twoDigitsdigitdiffTimeOfDay64baseData.Semigroup<>GHC.BaseString#text-1.2.2.2-KC7dWoG09dA1F6jKj5GSqhData.Text.InternalTextData.Time.Clock.POSIXgetCurrentTime$aeson-1.2.3.0-Ip8RjPBjTJpBF7QvZ30gY9Data.Aeson.Types.ToJSONtoJSONMonoid.safe-exceptions-0.1.6.0-53nliaH07DTHADJGH5g3AUControl.Exception.Safe onExceptiontemplate-haskellLanguage.Haskell.TH.SyntaxLoc Control.Monadforever replicateM_GHC.IO.Handle.Types LineBufferingGHC.IOFilePathHandle GHC.IO.IOMode AppendMode