Di

This module is a highly opinionated, basic, and yet sufficient choice of a concrete stack of logging solutions belonging to the di logging ecosystem—an otherwise rather general ecosystem, flexible and full of choices.

For most logging scenarios out there, the choices made here should suffice, but if you find these are not sufficient for your particular use case, please refer to other libraries of the di logging ecosystem such as di-core, di-monad, di-handle, or di-df1, and you are likely to find a compatible and composable solution there. For this reason, staring with this package rather than one of the those other lower-level packages is always recommended.

The choices made here are:

• We encourage a mtl approach through a typeclass called MonadDi, for which all of the monad transformers in transformers and pipes have instances.
• We provide our own DiT monad transformer which has a MonadDi instance, as well as instances for all the relevant typeclasses in the base, mtl, and exceptions libraries. All of the MonadDi instances exported by this package expect a DiT transformer in the stack somewhere, and defer all work to it.
• We embrace the df1 hierarchical structured logging format, both at the type-level and when rendering the log lines as text. Most notably, this means that we embrace the df1 importance Levels.
• We commit logs to the outside world by printing them to stderr.
• Exceptions are logged at their throw site (see onException).

You will notice that some of the functions in this module mention the types Level, Path and Message, and some other functions talk about level, path and msg type variables. This is because even while our particular set of choices require some monomorphic types, as demonstrated by the Df1 and MonadDf1 type-synonyms, the larger di logging ecosystem treats these values polymorphically, so they will show up in the types in one way or another, either in concrete or polymorphic form. This can seem a bit noisy, but the good news is that if, for example, want to call a third party library that uses other types for conveying the idea of a “log importance level” or a “log message”, then you can do so if you can convert between these different types. You are of course encouraged to use the Df1 and MonadDf1 type-synonyms yourself. For more information about this, see Di.Monad and Di.Core, but not today.

The intended usage of this module is:

import qualified Di

Documentation

new

Arguments

:: (MonadIO m, MonadMask m)

=> (Di Level Path Message -> m a)

This type is the same as Df1 -> m a.

Within this scope, you can use the obtained Di safely, even concurrently. As soon as m a finishes, new will block until all logs have finished processing, before returning.

WARNING: Even while new commit pure :: m (Di Level Path Message) type-checks, attempting to use the obtained Di outside its intended scope will fail.

-> m a

Obtain a Di that will write logs in the df1 format to stderr.

Generally, you will want to call new just once per application, right from your main function. For example:

main :: IO ()
main = do
   -- First you obtain a Di.
   -- You do this once per application, in main.
   new $ \di -> do
      -- You can start logging right away by acting
      -- on the on the Di object, but here
      -- we encourage using runDiT and perforfing
      -- all your logging from within a MonadDf1.
      runDiT di $ do
          -- Our first log message!
          notice_ "Welcome to my program!"
          -- You can use push to separate different
          -- logging scopes of your program:
          push "initialization" $ do
              notice_ "Starting web server"
              alert_ "Disk is almost full!!!"
          -- Yet another scope.
          push "server" $ do
              -- You can use attr to add metadata to
              -- messages logged within a particular scope.
              attr "port" (80 :: Int) $ do
                   info_ "Listening for new clients"
                   clientAddress <- do
                      -- This is just an example. Whatever.
                      pure ("10.0.0.8" :: String)
                   push "handler" $ do
                      attr "client-address" clientAddress $ do
                         info_ "Connection established"
                         -- If you throw an exception with throw,
                         -- it will be logged automatically together
                         -- with its current scope. Isn't that nice?
                         throw (userError "Oops!")

That program will render something like this to stderr:

You get the nice colors only if the output is going to a TTY. Otherwise, you get the same, but without any colors.

2019-11-15T18:05:54.949470902Z NOTICE Welcome to my program!
2019-11-15T18:05:54.949623731Z /initialization NOTICE Starting web server
2019-11-15T18:05:54.949630205Z /initialization ALERT Disk is almost full!!!
2019-11-15T18:05:54.949640299Z /server port=80 INFO Listening for new clients
2019-11-15T18:05:54.949652133Z /server port=80 /handler client-address=10.0.0.8 INFO Connection established
2019-11-15T18:05:54.949664482Z /server port=80 /handler client-address=10.0.0.8 WARNING user error (Oops!)

Notice that by default, all exceptions thrown using throw are logged at their throw site with Warning level. You can change that if you care using onException.

Unrelated: df1 escapes conflicting punctuation characters as necessary.

Hierarchy

push

Arguments

:: MonadDi level Path msg m

=> Segment

-> m a

-> m a

Push a new Segment to the MonadDi.

Metadata

attr

Arguments

:: (MonadDi level Path msg m, ToValue value)

=> Key

-> value

-> m a

-> m a

Push a new attribute Key and Value to the MonadDi.

attr_

Arguments

:: MonadDi level Path msg m

=> Key

-> Value

-> m a

-> m a

Like attr, but takes a Value rather than any ToValue.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

Logging

debug :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log a message intended to be useful only when deliberately debugging a program.

info :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log an informational message.

notice :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log a condition that is not an error, but should possibly be handled specially.

warning :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log a warning condition, such as an exception being gracefully handled or some missing configuration setting being assigned a default value.

error :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log an error condition, such as an unhandled exception.

alert :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log a condition that should be corrected immediately, such as a corrupted database.

critical :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log a critical condition that could result in system failure, such as a disk running out of space.

emergency :: (MonadDi Level path Message m, ToMessage msg) => msg -> m ()

Log a message stating that the system is unusable.

Better type-inference

debug_ :: MonadDi Level path Message m => Message -> m ()

Like debug, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

info_ :: MonadDi Level path Message m => Message -> m ()

Like info, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

notice_ :: MonadDi Level path Message m => Message -> m ()

Like notice, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

warning_ :: MonadDi Level path Message m => Message -> m ()

Like warning, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

error_ :: MonadDi Level path Message m => Message -> m ()

Like error, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

alert_ :: MonadDi Level path Message m => Message -> m ()

Like alert, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

critical_ :: MonadDi Level path Message m => Message -> m ()

Like critical, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

emergency_ :: MonadDi Level path Message m => Message -> m ()

Like emergency, but takes a Message rather than any ToMessage.

This helps with type inference in case you are trying to log a literal string and have the OverloadedStrings GHC extension enabled.

Exceptions

throw :: (MonadDi level path msg m, Exception e) => e -> m a

Throw an Exception, but not without logging it first according to the rules established by onException, and further restricted by the rules established by filter.

If the exception doesn't need to be logged, according to the policy set with onException, then this function behaves just as throwSTM.

WARNING: Note that when m is STM, or ultimately runs on STM, then throw will not log the exception, just throw it. This might change in the future if we figure out how to make it work safely.

Support for MonadDi and DiT

runDiT

Arguments

:: MonadIO m

=> Di level path msg

-> DiT level path msg m a

-> m a

Run a DiT.

forall di.
   runDiT di (diT (\nat' di' -> pure (nat', di')))
       == pure (natSTM, di)

This is like runDiT', but specialized to run with an underlying MonadIO.

runDiT  ==  runDiT' (liftIO . atomically)

Please notice that runDiT doesn't perform a flush on the given Di before returning. You are responsible for doing that (or, more likely, new will do it for you).

Also, notice that runDiT is a monad morphism from DiT m to m.

hoistDiT

Arguments

:: (forall x. n x -> m x)

Natural transformation from n to m.

-> (forall x. m x -> n x)

Monad morphism from m to n.

-> DiT level path msg m a

Monad morphism from DiT m to DiT n.

-> DiT level path msg n a

Lift a monad morphism from m to n to a monad morphism from DiT level path msg m to DiT level path msg n.

Notice that DiT itself is not a functor in the category of monads, so it can't be an instance of MFunctor from the mmorph package. However, it becomes one if you pair it with a natural transformation nat :: forall x. n x -> m x. That is:

forall nat.  such that nat is a natural transformation
   hoistDiT nat  ==  hoist

In practical terms, it means that most times you can “hoist” a DiT anyway, just not through hoist.

class Monad m => MonadDi level path msg (m :: Type -> Type) | m -> level path msg where

A MonadDi allows interacting with a Di through a mtl-like monadic API, rather than through the “bare” API proposed by Di.Core.

Nevertheless, be aware that these two APIs are compatible, so you may choose to use the monadic API for some parts of your application, the “bare” API for some other parts, and everything will compose and behave as expected. Usually, runDiT is the boundary between these two APIs, although not necessarily.

Semantically, MonadDi m is a “reader monad” that carries as its environment a Di and natural transformation from STM to m.

Minimal complete definition

local

Methods

ask :: m (Di level path msg)

Get the Di inside m, unmodified.

Idempotence law:

ask >> ask  ==  ask

local :: (Di level path msg -> Di level path msg) -> m a -> m a

Run m a with a modified Di:

local (const x) ask  ==  pure x

Identity law:

local id x  ==  x

Distributive law:

local f . local g  ==  local (f . g)

Idempotence law:

local f (pure ()) >> x  ==  x

natSTM :: STM a -> m a

Natural transformation from STM to m.

Notice that it is not necessary for this natural transformation to be a monad morphism as well. That is, atomically is acceptable.

Instances

MonadDi level path msg m => MonadDi level path msg (MaybeT m)

Defined in Di.Monad

Methods

ask :: MaybeT m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> MaybeT m a -> MaybeT m a

natSTM :: STM a -> MaybeT m a

MonadDi level path msg m => MonadDi level path msg (ListT m)

Defined in Di.Monad

Methods

ask :: ListT m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> ListT m a -> ListT m a

natSTM :: STM a -> ListT m a

(Monoid w, MonadDi level path msg m) => MonadDi level path msg (WriterT w m)

Defined in Di.Monad

Methods

ask :: WriterT w m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> WriterT w m a -> WriterT w m a

natSTM :: STM a -> WriterT w m a

(Monoid w, MonadDi level path msg m) => MonadDi level path msg (WriterT w m)

Defined in Di.Monad

Methods

ask :: WriterT w m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> WriterT w m a -> WriterT w m a

natSTM :: STM a -> WriterT w m a

MonadDi level path msg m => MonadDi level path msg (StateT s m)

Defined in Di.Monad

Methods

ask :: StateT s m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> StateT s m a -> StateT s m a

natSTM :: STM a -> StateT s m a

MonadDi level path msg m => MonadDi level path msg (StateT s m)

Defined in Di.Monad

Methods

ask :: StateT s m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> StateT s m a -> StateT s m a

natSTM :: STM a -> StateT s m a

MonadDi level path msg m => MonadDi level path msg (SelectT r m)

Defined in Di.Monad

Methods

ask :: SelectT r m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> SelectT r m a -> SelectT r m a

natSTM :: STM a -> SelectT r m a

MonadDi level path msg m => MonadDi level path msg (IdentityT m)

Defined in Di.Monad

Methods

ask :: IdentityT m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> IdentityT m a -> IdentityT m a

natSTM :: STM a -> IdentityT m a

MonadDi level path msg m => MonadDi level path msg (ExceptT e m)

Defined in Di.Monad

Methods

ask :: ExceptT e m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> ExceptT e m a -> ExceptT e m a

natSTM :: STM a -> ExceptT e m a

(Monoid w, MonadDi level path msg m) => MonadDi level path msg (AccumT w m)

Defined in Di.Monad

Methods

ask :: AccumT w m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> AccumT w m a -> AccumT w m a

natSTM :: STM a -> AccumT w m a

MonadDi level path msg m => MonadDi level path msg (ReaderT r m)

Defined in Di.Monad

Methods

ask :: ReaderT r m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> ReaderT r m a -> ReaderT r m a

natSTM :: STM a -> ReaderT r m a

MonadDi level path msg m => MonadDi level path msg (ContT r m)

Defined in Di.Monad

Methods

ask :: ContT r m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> ContT r m a -> ContT r m a

natSTM :: STM a -> ContT r m a

(Monoid w, MonadDi level path msg m) => MonadDi level path msg (RWST r w s m)

Defined in Di.Monad

Methods

ask :: RWST r w s m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> RWST r w s m a -> RWST r w s m a

natSTM :: STM a -> RWST r w s m a

(Monoid w, MonadDi level path msg m) => MonadDi level path msg (RWST r w s m)

Defined in Di.Monad

Methods

ask :: RWST r w s m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> RWST r w s m a -> RWST r w s m a

natSTM :: STM a -> RWST r w s m a

Monad m => MonadDi level path msg (DiT level path msg m)

Defined in Di.Monad

Methods

ask :: DiT level path msg m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> DiT level path msg m a -> DiT level path msg m a

natSTM :: STM a -> DiT level path msg m a

MonadDi level path msg m => MonadDi level path msg (Proxy a' a b' b m)

Defined in Di.Monad

Methods

ask :: Proxy a' a b' b m (Di level path msg)

local :: (Di level path msg -> Di level path msg) -> Proxy a' a b' b m a0 -> Proxy a' a b' b m a0

natSTM :: STM a0 -> Proxy a' a b' b m a0

Convenient type-synonyms

type Df1 = Di Level Path Message

Convenience type-synonym for a Di restricted to all the df1 monomorphic types.

Df1 == Di Level Path Message
   :: *

This type-synonym is not used within the di-df1 library itself because all functions exposed in the library have more general types. However, users are encouraged to use Df1 if they find it useful to reduce boilerplate and improve type inference.

type Df1T = DiT Level Path Message

Convenience type-synonym for a DiT restricted to all the df1 monomorphic types.

Df1T == DiT Level Path Message
   :: (* -> *) -> * -> *

Df1T m == DiT Level Path Message m
   :: * -> *

Df1T m a == DiT Level Path Message m a
   :: *

This type-synonym is not used within the di-df1 library itself because all functions exposed in the library have more general types. However, users are encouraged to use MonadDf1 if they find it useful to reduce boilerplate and improve type inferrence.

type MonadDf1 = MonadDi Level Path Message

Convenience type-synonym for a MonadDi restricted to all the df1 monomorphic types.

MonadDf1 == MonadDi Level Path Message
   :: (* -> *) -> Constraint

MonadDf1 m == MonadDi Level Path Message m
   :: Constraint

This type-synonym is not used within the di-df1 library itself because all functions exposed in the library have more general types. However, users are encouraged to use MonadDf1 if they find it useful to reduce boilerplate and improve type inferrence.

Types from Df1

data Level

Importance of the logged message.

These levels, listed in increasing order of importance, correspond to the levels used by syslog(3).

Instances

Bounded Level

Defined in Df1.Types

Methods

minBound :: Level

maxBound :: Level

Enum Level

Defined in Df1.Types

Methods

succ :: Level -> Level

pred :: Level -> Level

toEnum :: Int -> Level

fromEnum :: Level -> Int

enumFrom :: Level -> [Level]

enumFromThen :: Level -> Level -> [Level]

enumFromTo :: Level -> Level -> [Level]

enumFromThenTo :: Level -> Level -> Level -> [Level]

Eq Level

Defined in Df1.Types

Methods

(==) :: Level -> Level -> Bool

(/=) :: Level -> Level -> Bool

Ord Level

Order of importance. For example, Emergency is more important than Debug:

Emergency > Debug  ==  True

Defined in Df1.Types

Methods

compare :: Level -> Level -> Ordering

(<) :: Level -> Level -> Bool

(<=) :: Level -> Level -> Bool

(>) :: Level -> Level -> Bool

(>=) :: Level -> Level -> Bool

max :: Level -> Level -> Level

min :: Level -> Level -> Level

Show Level

Defined in Df1.Types

Methods

showsPrec :: Int -> Level -> ShowS

show :: Level -> String

showList :: [Level] -> ShowS

data Path

Path represents the hierarchical structure of logged messages.

For example, consider a df1 log line as like the following:

1999-12-20T07:11:39.230553031Z /foo x=a y=b /bar /qux z=c z=d WARNING Something

For that line, the log_path attribute of the Log datatype will contain the following:

[ Push (segment "foo")
, Attr (key "x") (value "a")
, Attr (key "y") (value "b")
, Push (segment "bar")
, Push (segment "qux")
, Attr (key "z") (value "c")
, Attr (key "z") (value "d")
] :: Seq Path

Please notice that [] :: Seq Path is a valid path insofar as df1 is concerned, and that Attr and Push can be juxtapositioned in any order.

Instances

Eq Path

Defined in Df1.Types

Methods

(==) :: Path -> Path -> Bool

(/=) :: Path -> Path -> Bool

Show Path

Defined in Df1.Types

Methods

showsPrec :: Int -> Path -> ShowS

show :: Path -> String

showList :: [Path] -> ShowS

data Segment

A path segment.

If you have the OverloadedStrings GHC extension enabled, you can build a Segment using a string literal:

"foo" :: Segment

Otherwise, you can use fromString or segment.

Notice that "" :: Segment is acceptable, and will be correctly rendered and parsed back.

Instances

Eq Segment

Defined in Df1.Types

Methods

(==) :: Segment -> Segment -> Bool

(/=) :: Segment -> Segment -> Bool

Show Segment

Defined in Df1.Types

Methods

showsPrec :: Int -> Segment -> ShowS

show :: Segment -> String

showList :: [Segment] -> ShowS

IsString Segment

Defined in Df1.Types

Methods

fromString :: String -> Segment

Semigroup Segment

Defined in Df1.Types

Methods

(<>) :: Segment -> Segment -> Segment

sconcat :: NonEmpty Segment -> Segment

stimes :: Integral b => b -> Segment -> Segment

Monoid Segment

Defined in Df1.Types

Methods

mempty :: Segment

mappend :: Segment -> Segment -> Segment

mconcat :: [Segment] -> Segment

ToSegment Segment

Identity.

Defined in Df1.Types

Methods

segment :: Segment -> Segment

class ToSegment a where

Convert an arbitrary type to a Segment.

You are encouraged to create custom ToSegment instances for your types making sure you avoid rendering sensitive details such as passwords, so that they don't accidentally end up in logs.

Any characters that need to be escaped for rendering will be automatically escaped at rendering time. You don't need to escape them here.

Methods

segment :: a -> Segment

Instances

ToSegment Text

x :: Text == unSegment (segment x)

Defined in Df1.Types

Methods

segment :: Text -> Segment

ToSegment Text

x :: Text == toStrict (unSegment (segment x))

Defined in Df1.Types

Methods

segment :: Text -> Segment

ToSegment String

x :: String == unpack (unSegment (segment x))

Defined in Df1.Types

Methods

segment :: String -> Segment

ToSegment Segment

Identity.

Defined in Df1.Types

Methods

segment :: Segment -> Segment

data Key

An attribute key (see Attr).

If you have the OverloadedStrings GHC extension enabled, you can build a Key using a string literal:

"foo" :: Key

Otherwise, you can use fromString or key.

Notice that "" :: Key is acceptable, and will be correctly rendered and parsed back.

Instances

Eq Key

Defined in Df1.Types

Methods

(==) :: Key -> Key -> Bool

(/=) :: Key -> Key -> Bool

Show Key

Defined in Df1.Types

Methods

showsPrec :: Int -> Key -> ShowS

show :: Key -> String

showList :: [Key] -> ShowS

IsString Key

Defined in Df1.Types

Methods

fromString :: String -> Key

Semigroup Key

Defined in Df1.Types

Methods

(<>) :: Key -> Key -> Key

sconcat :: NonEmpty Key -> Key

stimes :: Integral b => b -> Key -> Key

Monoid Key

Defined in Df1.Types

Methods

mempty :: Key

mappend :: Key -> Key -> Key

mconcat :: [Key] -> Key

ToKey Key

Identity.

Defined in Df1.Types

Methods

key :: Key -> Key

class ToKey a where

Convert an arbitrary type to a Key.

You are encouraged to create custom ToKey instances for your types making sure you avoid rendering sensitive details such as passwords, so that they don't accidentally end up in logs.

Any characters that need to be escaped for rendering will be automatically escaped at rendering time. You don't need to escape them here.

Methods

key :: a -> Key

Instances

ToKey Text

x :: Text == unKey (key x)

Defined in Df1.Types

Methods

key :: Text -> Key

ToKey Text

x :: Text == toStrict (unKey (key x))

Defined in Df1.Types

Methods

key :: Text -> Key

ToKey String

x :: String == unpack (unKey (key x))

Defined in Df1.Types

Methods

key :: String -> Key

ToKey Key

Identity.

Defined in Df1.Types

Methods

key :: Key -> Key

data Value

An attribute value (see Attr).

If you have the OverloadedStrings GHC extension enabled, you can build a Value using a string literal:

"foo" :: Value

Otherwise, you can use fromString or value.

Notice that "" :: Value is acceptable, and will be correctly rendered and parsed back.

Instances

Eq Value

Defined in Df1.Types

Methods

(==) :: Value -> Value -> Bool

(/=) :: Value -> Value -> Bool

Show Value

Defined in Df1.Types

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

IsString Value

Defined in Df1.Types

Methods

fromString :: String -> Value

Semigroup Value

Defined in Df1.Types

Methods

(<>) :: Value -> Value -> Value

sconcat :: NonEmpty Value -> Value

stimes :: Integral b => b -> Value -> Value

Monoid Value

Defined in Df1.Types

Methods

mempty :: Value

mappend :: Value -> Value -> Value

mconcat :: [Value] -> Value

ToValue Value

Identity.

Defined in Df1.Types

Methods

value :: Value -> Value

class ToValue a where

Convert an arbitrary type to a Value.

You are encouraged to create custom ToValue instances for your types making sure you avoid rendering sensitive details such as passwords, so that they don't accidentally end up in logs.

Any characters that need to be escaped for rendering will be automatically escaped at rendering time. You don't need to escape them here.

Methods

value :: a -> Value

Instances

ToValue Bool

Defined in Df1.Types

Methods

value :: Bool -> Value

ToValue Double

Defined in Df1.Types

Methods

value :: Double -> Value

ToValue Float

Defined in Df1.Types

Methods

value :: Float -> Value

ToValue Int

Defined in Df1.Types

Methods

value :: Int -> Value

ToValue Int8

Defined in Df1.Types

Methods

value :: Int8 -> Value

ToValue Int16

Defined in Df1.Types

Methods

value :: Int16 -> Value

ToValue Int32

Defined in Df1.Types

Methods

value :: Int32 -> Value

ToValue Int64

Defined in Df1.Types

Methods

value :: Int64 -> Value

ToValue Integer

Defined in Df1.Types

Methods

value :: Integer -> Value

ToValue Natural

Defined in Df1.Types

Methods

value :: Natural -> Value

ToValue Word

Defined in Df1.Types

Methods

value :: Word -> Value

ToValue Word8

Defined in Df1.Types

Methods

value :: Word8 -> Value

ToValue Word16

Defined in Df1.Types

Methods

value :: Word16 -> Value

ToValue Word32

Defined in Df1.Types

Methods

value :: Word32 -> Value

ToValue Word64

Defined in Df1.Types

Methods

value :: Word64 -> Value

ToValue Text

x :: Text == unValue (value x)

Defined in Df1.Types

Methods

value :: Text -> Value

ToValue Text

x :: Text == toStrict (unValue (value x))

Defined in Df1.Types

Methods

value :: Text -> Value

ToValue String

x :: String == unpack (unValue (value x))

Defined in Df1.Types

Methods

value :: String -> Value

ToValue SomeException

Defined in Df1.Types

Methods

value :: SomeException -> Value

ToValue Value

Identity.

Defined in Df1.Types

Methods

value :: Value -> Value

data Message

A message text.

If you have the OverloadedStrings GHC extension enabled, you can build a Message using a string literal:

"foo" :: Message

Otherwise, you can use fromString or message.

Notice that "" :: Message is acceptable, and will be correctly rendered and parsed back.

Instances

Eq Message

Defined in Df1.Types

Methods

(==) :: Message -> Message -> Bool

(/=) :: Message -> Message -> Bool

Show Message

Defined in Df1.Types

Methods

showsPrec :: Int -> Message -> ShowS

show :: Message -> String

showList :: [Message] -> ShowS

IsString Message

Defined in Df1.Types

Methods

fromString :: String -> Message

Semigroup Message

Defined in Df1.Types

Methods

(<>) :: Message -> Message -> Message

sconcat :: NonEmpty Message -> Message

stimes :: Integral b => b -> Message -> Message

Monoid Message

Defined in Df1.Types

Methods

mempty :: Message

mappend :: Message -> Message -> Message

mconcat :: [Message] -> Message

ToMessage Message

Identity.

Defined in Df1.Types

Methods

message :: Message -> Message

class ToMessage a where

Convert an arbitrary type to a Message.

You are encouraged to create custom ToMessage instances for your types making sure you avoid rendering sensitive details such as passwords, so that they don't accidentally end up in logs.

Any characters that need to be escaped for rendering will be automatically escaped at rendering time. You don't need to escape them here.

Methods

message :: a -> Message

Instances

ToMessage Text

x :: Text == unMessage (message x)

Defined in Df1.Types

Methods

message :: Text -> Message

ToMessage Text

x :: Text == toStrict (unMessage (message x))

Defined in Df1.Types

Methods

message :: Text -> Message

ToMessage String

x :: String == unpack (unMessage (message x))

Defined in Df1.Types

Methods

message :: String -> Message

ToMessage SomeException

Defined in Df1.Types

Methods

message :: SomeException -> Message

ToMessage Message

Identity.

Defined in Df1.Types

Methods

message :: Message -> Message