katip-0.8.5.0: A structured logging framework.

Safe HaskellNone
LanguageHaskell2010

Katip.Core

Description

This module is not meant to be imported directly and may contain internal mechanisms that will change without notice.

Synopsis

Documentation

newtype Namespace Source #

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"].

Constructors

Namespace 

Fields

Instances
Eq Namespace Source # 
Instance details

Defined in Katip.Core

Ord Namespace Source # 
Instance details

Defined in Katip.Core

Read Namespace Source # 
Instance details

Defined in Katip.Core

Show Namespace Source # 
Instance details

Defined in Katip.Core

IsString Namespace Source # 
Instance details

Defined in Katip.Core

Generic Namespace Source # 
Instance details

Defined in Katip.Core

Associated Types

type Rep Namespace :: Type -> Type #

Semigroup Namespace Source # 
Instance details

Defined in Katip.Core

Monoid Namespace Source # 
Instance details

Defined in Katip.Core

Lift Namespace Source # 
Instance details

Defined in Katip.Core

Methods

lift :: Namespace -> Q Exp #

ToJSON Namespace Source # 
Instance details

Defined in Katip.Core

FromJSON Namespace Source # 
Instance details

Defined in Katip.Core

type Rep Namespace Source # 
Instance details

Defined in Katip.Core

type Rep Namespace = D1 (MetaData "Namespace" "Katip.Core" "katip-0.8.5.0-L71m4manfVnHjtNmXtAPdW" True) (C1 (MetaCons "Namespace" PrefixI True) (S1 (MetaSel (Just "unNamespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Text])))

intercalateNs :: Namespace -> [Text] Source #

Ready namespace for emission with dots to join the segments.

newtype Environment Source #

Application environment, like prod, devel, testing.

Constructors

Environment 

Fields

Instances
Eq Environment Source # 
Instance details

Defined in Katip.Core

Ord Environment Source # 
Instance details

Defined in Katip.Core

Read Environment Source # 
Instance details

Defined in Katip.Core

Show Environment Source # 
Instance details

Defined in Katip.Core

IsString Environment Source # 
Instance details

Defined in Katip.Core

Generic Environment Source # 
Instance details

Defined in Katip.Core

Associated Types

type Rep Environment :: Type -> Type #

ToJSON Environment Source # 
Instance details

Defined in Katip.Core

FromJSON Environment Source # 
Instance details

Defined in Katip.Core

type Rep Environment Source # 
Instance details

Defined in Katip.Core

type Rep Environment = D1 (MetaData "Environment" "Katip.Core" "katip-0.8.5.0-L71m4manfVnHjtNmXtAPdW" True) (C1 (MetaCons "Environment" PrefixI True) (S1 (MetaSel (Just "getEnvironment") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data Severity Source #

Constructors

DebugS

Debug messages

InfoS

Information

NoticeS

Normal runtime Conditions

WarningS

General Warnings

ErrorS

General Errors

CriticalS

Severe situations

AlertS

Take immediate action

EmergencyS

System is unusable

Instances
Bounded Severity Source # 
Instance details

Defined in Katip.Core

Enum Severity Source # 
Instance details

Defined in Katip.Core

Eq Severity Source # 
Instance details

Defined in Katip.Core

Ord Severity Source # 
Instance details

Defined in Katip.Core

Read Severity Source # 
Instance details

Defined in Katip.Core

Show Severity Source # 
Instance details

Defined in Katip.Core

Generic Severity Source # 
Instance details

Defined in Katip.Core

Associated Types

type Rep Severity :: Type -> Type #

Methods

from :: Severity -> Rep Severity x #

to :: Rep Severity x -> Severity #

Lift Severity Source # 
Instance details

Defined in Katip.Core

Methods

lift :: Severity -> Q Exp #

ToJSON Severity Source # 
Instance details

Defined in Katip.Core

FromJSON Severity Source # 
Instance details

Defined in Katip.Core

type Rep Severity Source # 
Instance details

Defined in Katip.Core

type Rep Severity = D1 (MetaData "Severity" "Katip.Core" "katip-0.8.5.0-L71m4manfVnHjtNmXtAPdW" False) (((C1 (MetaCons "DebugS" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "InfoS" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "NoticeS" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "WarningS" PrefixI False) (U1 :: Type -> Type))) :+: ((C1 (MetaCons "ErrorS" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "CriticalS" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "AlertS" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "EmergencyS" PrefixI False) (U1 :: Type -> Type))))

data Verbosity Source #

Verbosity controls the amount of information (columns) a Scribe emits during logging.

The convention is: - V0 implies no additional payload information is included in message. - V3 implies the maximum amount of payload information. - Anything in between is left to the discretion of the developer.

Constructors

V0 
V1 
V2 
V3 
Instances
Bounded Verbosity Source # 
Instance details

Defined in Katip.Core

Enum Verbosity Source # 
Instance details

Defined in Katip.Core

Eq Verbosity Source # 
Instance details

Defined in Katip.Core

Ord Verbosity Source # 
Instance details

Defined in Katip.Core

Read Verbosity Source # 
Instance details

Defined in Katip.Core

Show Verbosity Source # 
Instance details

Defined in Katip.Core

Generic Verbosity Source # 
Instance details

Defined in Katip.Core

Associated Types

type Rep Verbosity :: Type -> Type #

Lift Verbosity Source # 
Instance details

Defined in Katip.Core

Methods

lift :: Verbosity -> Q Exp #

ToJSON Verbosity Source # 
Instance details

Defined in Katip.Core

FromJSON Verbosity Source # 
Instance details

Defined in Katip.Core

type Rep Verbosity Source # 
Instance details

Defined in Katip.Core

type Rep Verbosity = D1 (MetaData "Verbosity" "Katip.Core" "katip-0.8.5.0-L71m4manfVnHjtNmXtAPdW" False) ((C1 (MetaCons "V0" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "V1" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "V2" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "V3" PrefixI False) (U1 :: Type -> Type)))

newtype LogStr Source #

Log message with Builder underneath; use <> to concat in O(1).

Constructors

LogStr 

Fields

Instances
Eq LogStr Source # 
Instance details

Defined in Katip.Core

Methods

(==) :: LogStr -> LogStr -> Bool #

(/=) :: LogStr -> LogStr -> Bool #

Show LogStr Source # 
Instance details

Defined in Katip.Core

IsString LogStr Source # 
Instance details

Defined in Katip.Core

Methods

fromString :: String -> LogStr #

Generic LogStr Source # 
Instance details

Defined in Katip.Core

Associated Types

type Rep LogStr :: Type -> Type #

Methods

from :: LogStr -> Rep LogStr x #

to :: Rep LogStr x -> LogStr #

Semigroup LogStr Source # 
Instance details

Defined in Katip.Core

Monoid LogStr Source # 
Instance details

Defined in Katip.Core

FromJSON LogStr Source # 
Instance details

Defined in Katip.Core

type Rep LogStr Source # 
Instance details

Defined in Katip.Core

type Rep LogStr = D1 (MetaData "LogStr" "Katip.Core" "katip-0.8.5.0-L71m4manfVnHjtNmXtAPdW" True) (C1 (MetaCons "LogStr" PrefixI True) (S1 (MetaSel (Just "unLogStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Builder)))

logStr :: StringConv a Text => a -> LogStr Source #

Pack any string-like thing into a LogStr. This will automatically work on String, ByteString, Text and any of the lazy variants.

ls :: StringConv a Text => a -> LogStr Source #

Shorthand for logStr

showLS :: Show a => a -> LogStr Source #

Convert any showable type into a LogStr.

data Item a Source #

This has everything each log message will contain.

Instances
Functor Item Source # 
Instance details

Defined in Katip.Core

Methods

fmap :: (a -> b) -> Item a -> Item b #

(<$) :: a -> Item b -> Item a #

Eq a => Eq (Item a) Source # 
Instance details

Defined in Katip.Core

Methods

(==) :: Item a -> Item a -> Bool #

(/=) :: Item a -> Item a -> Bool #

Show a => Show (Item a) Source # 
Instance details

Defined in Katip.Core

Methods

showsPrec :: Int -> Item a -> ShowS #

show :: Item a -> String #

showList :: [Item a] -> ShowS #

Generic (Item a) Source # 
Instance details

Defined in Katip.Core

Associated Types

type Rep (Item a) :: Type -> Type #

Methods

from :: Item a -> Rep (Item a) x #

to :: Rep (Item a) x -> Item a #

ToJSON a => ToJSON (Item a) Source # 
Instance details

Defined in Katip.Core

FromJSON a => FromJSON (Item a) Source # 
Instance details

Defined in Katip.Core

type Rep (Item a) Source # 
Instance details

Defined in Katip.Core

itemTime :: forall a. Lens' (Item a) UTCTime Source #

itemPayload :: forall a a. Lens (Item a) (Item a) a a Source #

itemMessage :: forall a. Lens' (Item a) LogStr Source #

itemLoc :: forall a. Lens' (Item a) (Maybe Loc) Source #

itemHost :: forall a. Lens' (Item a) HostName Source #

itemApp :: forall a. Lens' (Item a) Namespace Source #

newtype LocShow Source #

Constructors

LocShow Loc 
Instances
Show LocShow Source # 
Instance details

Defined in Katip.Core

newtype LocJs Source #

Constructors

LocJs 

Fields

Instances
ToJSON LocJs Source # 
Instance details

Defined in Katip.Core

FromJSON LocJs Source # 
Instance details

Defined in Katip.Core

class ToObject a where Source #

Katip requires JSON objects to be logged as context. This typeclass provides a default instance which uses ToJSON and produces an empty object if toJSON 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

Minimal complete definition

Nothing

Methods

toObject :: a -> Object Source #

toObject :: ToJSON a => a -> Object Source #

Instances
ToObject () Source # 
Instance details

Defined in Katip.Core

Methods

toObject :: () -> Object Source #

ToObject Object Source # 
Instance details

Defined in Katip.Core

ToObject SimpleLogPayload Source # 
Instance details

Defined in Katip.Core

ToObject LogContexts Source # 
Instance details

Defined in Katip.Monadic

class ToObject a => LogItem a where Source #

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 Scribe can be configured with a different Verbosity level. You could even use registerScribe, unregisterScribe, and clearScribes to at runtime swap out your existing scribes for more verbose debugging scribes if you wanted to.

When defining payloadKeys, 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.

Methods

payloadKeys :: Verbosity -> a -> PayloadSelection Source #

List of keys in the JSON object that should be included in message.

Instances
LogItem () Source # 
Instance details

Defined in Katip.Core

LogItem SimpleLogPayload Source # 
Instance details

Defined in Katip.Core

LogItem LogContexts Source # 
Instance details

Defined in Katip.Monadic

data AnyLogPayload Source #

Constructors

ToJSON a => AnyLogPayload a 

newtype SimpleLogPayload Source #

Instances
Semigroup SimpleLogPayload Source # 
Instance details

Defined in Katip.Core

Monoid SimpleLogPayload Source # 
Instance details

Defined in Katip.Core

ToJSON SimpleLogPayload Source #

A built-in convenience log payload that won't log anything on V0, 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 sl and combine multiple tuples using <> from Monoid.

Instance details

Defined in Katip.Core

LogItem SimpleLogPayload Source # 
Instance details

Defined in Katip.Core

ToObject SimpleLogPayload Source # 
Instance details

Defined in Katip.Core

sl :: ToJSON a => Text -> a -> SimpleLogPayload Source #

Construct a simple log from any JSON item.

payloadObject :: LogItem a => Verbosity -> a -> Object Source #

Constrain payload based on verbosity. Backends should use this to automatically bubble higher verbosity levels to lower ones.

itemJson :: LogItem a => Verbosity -> Item a -> Value Source #

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.

type PermitFunc = forall a. Item a -> IO Bool Source #

Scribes are handlers of incoming items. Each registered scribe knows how to push a log item somewhere.

Guidelines for writing your own Scribe

Scribes should always take a Severity and Verbosity.

Severity is used to exclude log messages that are lower than the provided Severity. For instance, if the user passes InfoS, DebugS items should be ignored. Katip provides the permitItem utility for this. The user or the scribe may use permitAND and permitOR to further customize this filtering, even dynamically if they wish to.

Verbosity is used to select keys from the log item's payload. Each LogItem instance describes what keys should be retained for each Verbosity level. Use the payloadObject utility for extracting the keys that should be written.

Scribes provide a finalizer IO action (scribeFinalizer) that is meant to synchronously flush any remaining writes and clean up any resources acquired when the scribe was created. Internally, katip keeps a buffer for each scribe's writes. When closeScribe or closeScribes is called, that buffer stops accepting new log messages and after the last item in its buffer is sent to liPush, calls the finalizer. Thus, when the finalizer returns, katip can assume that all resources are cleaned up and all log messages are durably written.

While katip internally buffers messages per ScribeSettings, it sends them one at a time to the scribe. Depending on the scribe itself, it may make sense for that scribe to keep its own internal buffer to batch-send logs if writing items one at a time is not efficient. The scribe implementer must be sure that on finalization, all writes are committed synchronously.

Signature of a function passed to Scribe constructor and mkScribe* functions that decides which messages to be logged. Typically filters based on Severity, but can be combined with other, custom logic with permitAND and permitOR

permitAND :: PermitFunc -> PermitFunc -> PermitFunc Source #

AND together 2 permit functions

permitOR :: PermitFunc -> PermitFunc -> PermitFunc Source #

OR together 2 permit functions

data Scribe Source #

Constructors

Scribe 

Fields

  • liPush :: forall a. LogItem a => Item a -> IO ()

    How do we write an item to the scribe's output?

  • scribeFinalizer :: IO ()

    Provide a blocking finalizer to call when your scribe is removed. All pending writes should be flushed synchronously. If this is not relevant to your scribe, return () is fine.

  • scribePermitItem :: PermitFunc

    Provide a filtering function to allow the item to be logged, or not. It can check Severity or some string in item's body. The initial value of this is usually created from permitItem. Scribes and users can customize this by ANDing or ORing onto the default with permitAND or permitOR

Instances
Semigroup Scribe Source #

Combine 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.

Instance details

Defined in Katip.Core

Monoid Scribe Source # 
Instance details

Defined in Katip.Core

whenM :: Monad m => m Bool -> m () -> m () Source #

permitItem :: Monad m => Severity -> Item a -> m Bool Source #

Should this item be logged given the user's maximum severity? Most new scribes will use this as a base for their PermitFunc

data LogEnv Source #

Constructors

LogEnv 

Fields

initLogEnv Source #

Arguments

:: Namespace

A base namespace for this application

-> Environment

Current run environment (e.g. prod vs. devel)

-> IO LogEnv 

Create a reasonable default InitLogEnv. Uses an AutoUdate which updates the timer every 1ms. If you need even more timestamp precision at the cost of performance, consider setting _logEnvTimer with getCurrentTime.

registerScribe Source #

Arguments

:: Text

Name the scribe

-> Scribe 
-> ScribeSettings 
-> LogEnv 
-> IO LogEnv 

Add 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.

defaultScribeSettings :: ScribeSettings Source #

Reasonable defaults for a scribe. Buffer size of 4096.

unregisterScribe Source #

Arguments

:: Text

Name of the scribe

-> LogEnv 
-> LogEnv 

Remove 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.

clearScribes :: LogEnv -> LogEnv Source #

Unregister all scribes. Note that this is not for closing or finalizing scribes, use closeScribes 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.

closeScribe Source #

Arguments

:: Text

Name of the scribe

-> LogEnv 
-> IO LogEnv 

Finalize 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.

closeScribes :: LogEnv -> IO LogEnv Source #

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.

class MonadIO m => Katip m where Source #

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.

For 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.

localLogEnv was added to allow for lexically-scoped modifications of the log env that are reverted when the supplied monad completes. katipNoLogging, for example, uses this to temporarily pause log outputs.

Methods

getLogEnv :: m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> m a -> m a Source #

Instances
Katip m => Katip (MaybeT m) Source # 
Instance details

Defined in Katip.Core

Katip m => Katip (ResourceT m) Source # 
Instance details

Defined in Katip.Core

MonadIO m => Katip (KatipT m) Source # 
Instance details

Defined in Katip.Core

MonadIO m => Katip (NoLoggingT m) Source # 
Instance details

Defined in Katip.Monadic

MonadIO m => Katip (KatipContextT m) Source # 
Instance details

Defined in Katip.Monadic

Katip m => Katip (ExceptT s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: ExceptT s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> ExceptT s m a -> ExceptT s m a Source #

(Katip m, Monoid s) => Katip (WriterT s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: WriterT s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> WriterT s m a -> WriterT s m a Source #

Katip m => Katip (StateT s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: StateT s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> StateT s m a -> StateT s m a Source #

Katip m => Katip (StateT s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: StateT s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> StateT s m a -> StateT s m a Source #

(Katip m, Monoid s) => Katip (WriterT s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: WriterT s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> WriterT s m a -> WriterT s m a Source #

Katip m => Katip (ReaderT s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: ReaderT s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> ReaderT s m a -> ReaderT s m a Source #

(Katip m, Monoid w) => Katip (RWST r w s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: RWST r w s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> RWST r w s m a -> RWST r w s m a Source #

(Katip m, Monoid w) => Katip (RWST r w s m) Source # 
Instance details

Defined in Katip.Core

Methods

getLogEnv :: RWST r w s m LogEnv Source #

localLogEnv :: (LogEnv -> LogEnv) -> RWST r w s m a -> RWST r w s m a Source #

newtype KatipT m a Source #

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 Katip for your monad.

Constructors

KatipT 

Fields

Instances
MonadTrans KatipT Source # 
Instance details

Defined in Katip.Core

Methods

lift :: Monad m => m a -> KatipT m a #

MonadTransControl KatipT Source # 
Instance details

Defined in Katip.Core

Associated Types

type StT KatipT a :: Type #

Methods

liftWith :: Monad m => (Run KatipT -> m a) -> KatipT m a #

restoreT :: Monad m => m (StT KatipT a) -> KatipT m a #

MonadBase b m => MonadBase b (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

liftBase :: b α -> KatipT m α #

MonadBaseControl b m => MonadBaseControl b (KatipT m) Source # 
Instance details

Defined in Katip.Core

Associated Types

type StM (KatipT m) a :: Type #

Methods

liftBaseWith :: (RunInBase (KatipT m) b -> b a) -> KatipT m a #

restoreM :: StM (KatipT m) a -> KatipT m a #

Monad m => Monad (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

(>>=) :: KatipT m a -> (a -> KatipT m b) -> KatipT m b #

(>>) :: KatipT m a -> KatipT m b -> KatipT m b #

return :: a -> KatipT m a #

fail :: String -> KatipT m a #

Functor m => Functor (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

fmap :: (a -> b) -> KatipT m a -> KatipT m b #

(<$) :: a -> KatipT m b -> KatipT m a #

MonadFail m => MonadFail (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

fail :: String -> KatipT m a #

Applicative m => Applicative (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

pure :: a -> KatipT m a #

(<*>) :: KatipT m (a -> b) -> KatipT m a -> KatipT m b #

liftA2 :: (a -> b -> c) -> KatipT m a -> KatipT m b -> KatipT m c #

(*>) :: KatipT m a -> KatipT m b -> KatipT m b #

(<*) :: KatipT m a -> KatipT m b -> KatipT m a #

MonadIO m => MonadIO (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

liftIO :: IO a -> KatipT m a #

MonadThrow m => MonadThrow (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

throwM :: Exception e => e -> KatipT m a #

MonadCatch m => MonadCatch (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

catch :: Exception e => KatipT m a -> (e -> KatipT m a) -> KatipT m a #

MonadMask m => MonadMask (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

mask :: ((forall a. KatipT m a -> KatipT m a) -> KatipT m b) -> KatipT m b #

uninterruptibleMask :: ((forall a. KatipT m a -> KatipT m a) -> KatipT m b) -> KatipT m b #

generalBracket :: KatipT m a -> (a -> ExitCase b -> KatipT m c) -> (a -> KatipT m b) -> KatipT m (b, c) #

MonadResource m => MonadResource (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

liftResourceT :: ResourceT IO a -> KatipT m a #

MonadUnliftIO m => MonadUnliftIO (KatipT m) Source # 
Instance details

Defined in Katip.Core

Methods

withRunInIO :: ((forall a. KatipT m a -> IO a) -> IO b) -> KatipT m b #

MonadIO m => Katip (KatipT m) Source # 
Instance details

Defined in Katip.Core

(Monad m, KatipContext m) => KatipContext (KatipT m) Source # 
Instance details

Defined in Katip.Monadic

type StT KatipT a Source # 
Instance details

Defined in Katip.Core

type StT KatipT a = a
type StM (KatipT m) a Source # 
Instance details

Defined in Katip.Core

type StM (KatipT m) a = ComposeSt KatipT m a

runKatipT :: LogEnv -> KatipT m a -> m a Source #

Execute KatipT on a log env.

katipNoLogging :: Katip m => m a -> m a Source #

Disable all scribes for the given monadic action, then restore them afterwards. Works in any Katip monad.

logItem :: (Applicative m, LogItem a, Katip m) => a -> Namespace -> Maybe Loc -> Severity -> LogStr -> m () Source #

Log with everything, including a source code location. This is very low level and you typically can use logT in its place.

logKatipItem :: (Applicative m, LogItem a, Katip m) => Item a -> m () Source #

Log already constructed Item. This is the lowest level function that other log* functions use. It can be useful when implementing centralised logging services.

tryWriteTBQueue Source #

Arguments

:: TBQueue a 
-> a 
-> STM Bool

Did we write?

logF Source #

Arguments

:: (Applicative m, LogItem a, Katip m) 
=> a

Contextual payload for the log

-> Namespace

Specific namespace of the message.

-> Severity

Severity of the message

-> LogStr

The log message

-> m () 

Log with full context, but without any code location.

logException Source #

Arguments

:: (Katip m, LogItem a, MonadCatch m, Applicative m) 
=> a

Log context

-> Namespace

Namespace

-> Severity

Severity

-> m b

Main action being run

-> m b 

Perform an action while logging any exceptions that may occur. Inspired by onException.

>>> > logException () mempty ErrorS (error "foo")

logMsg :: (Applicative m, Katip m) => Namespace -> Severity -> LogStr -> m () Source #

Log a message without any payload/context or code location.

liftLoc :: Loc -> Q Exp Source #

Lift a location into an Exp.

getLoc :: HasCallStack => Maybe Loc Source #

For use when you want to include location in your logs. This will fill the 'Maybe Loc' gap in logF of this module, and relies on implicit callstacks when available (GHC > 7.8).

logT :: ExpQ Source #

Loc-tagged logging when using template-haskell.

$(logT) obj mempty InfoS "Hello world"

logLoc :: (Applicative m, LogItem a, Katip m, HasCallStack) => a -> Namespace -> Severity -> LogStr -> m () Source #

Loc-tagged logging using Stack when available.

This function does not require template-haskell as it automatically uses implicit-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 logT for maximum compatibility.

logLoc obj mempty InfoS "Hello world"