{-# LANGUAGE ScopedTypeVariables #-}

module Hermod.Tracing.Trace.Annotations (
    filterTraceBySeverity
  , filterTraceByPrivacy

  , setSeverity
  , withSeverity
  , privately
  , setPrivacy
  , withPrivacy
  , allPublic
  , allConfidential
  , setDetails
  , withDetails

  , withNames
  , appendPrefixName
  , appendPrefixNames
  , appendInnerName
  , appendInnerNames
  , withInnerNames
  , withLoggingContext
) where

import           Hermod.Tracing.Trace (filterTrace)
import           Hermod.Tracing.Types

import qualified Control.Tracer as T
import           Data.Maybe     (isJust)
import           Data.Text      (Text)


--- | Only process messages with severity ≥ the given minimum.
filterTraceBySeverity :: Monad m
  => Maybe SeverityF
  -> Trace m a
  -> Trace m a
filterTraceBySeverity :: forall (m :: * -> *) a.
Monad m =>
Maybe SeverityF -> Trace m a -> Trace m a
filterTraceBySeverity (Just SeverityF
minSeverity) =
    ((LoggingContext, a) -> Bool) -> Trace m a -> Trace m a
forall (m :: * -> *) a.
Monad m =>
((LoggingContext, a) -> Bool) -> Trace m a -> Trace m a
filterTrace
      (\(LoggingContext
lc, a
_) -> case LoggingContext -> Maybe SeverityS
lcSeverity LoggingContext
lc of
                      Just SeverityS
s  -> case SeverityF
minSeverity of
                                    SeverityF (Just SeverityS
fs) -> SeverityS
s SeverityS -> SeverityS -> Bool
forall a. Ord a => a -> a -> Bool
>= SeverityS
fs
                                    SeverityF Maybe SeverityS
Nothing   -> Bool
False
                      Maybe SeverityS
Nothing -> Bool
True)
filterTraceBySeverity Maybe SeverityF
Nothing = Trace m a -> Trace m a
forall a. a -> a
id

--- | Only process messages whose privacy level ≥ the given minimum.
filterTraceByPrivacy :: Monad m
  => Maybe Privacy
  -> Trace m a
  -> Trace m a
filterTraceByPrivacy :: forall (m :: * -> *) a.
Monad m =>
Maybe Privacy -> Trace m a -> Trace m a
filterTraceByPrivacy (Just Privacy
minPrivacy) = ((LoggingContext, a) -> Bool) -> Trace m a -> Trace m a
forall (m :: * -> *) a.
Monad m =>
((LoggingContext, a) -> Bool) -> Trace m a -> Trace m a
filterTrace (((LoggingContext, a) -> Bool) -> Trace m a -> Trace m a)
-> ((LoggingContext, a) -> Bool) -> Trace m a -> Trace m a
forall a b. (a -> b) -> a -> b
$
    \(LoggingContext
lc, a
_cont) ->
        case LoggingContext -> Maybe Privacy
lcPrivacy LoggingContext
lc of
          Just Privacy
s  -> Privacy -> Int
forall a. Enum a => a -> Int
fromEnum Privacy
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Privacy -> Int
forall a. Enum a => a -> Int
fromEnum Privacy
minPrivacy
          Maybe Privacy
Nothing -> Bool
True
filterTraceByPrivacy Maybe Privacy
Nothing = Trace m a -> Trace m a
forall a. a -> a
id


-- | Set a fixed 'SeverityS' on every message (no-op if already set).
setSeverity :: Monad m => SeverityS -> Trace m a -> Trace m a
setSeverity :: forall (m :: * -> *) a.
Monad m =>
SeverityS -> Trace m a -> Trace m a
setSeverity SeverityS
s (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) ->
          if Maybe SeverityS -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe SeverityS
lcSeverity LoggingContext
lc)
            then (LoggingContext
lc, Either TraceControl a
cont)
            else (LoggingContext
lc {lcSeverity = Just s}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Set severity from the 'MetaTrace' instance for each message.
{-# INLINE withSeverity #-}
withSeverity :: forall m a. (Monad m, MetaTrace a) => Trace m a -> Trace m a
withSeverity :: forall (m :: * -> *) a.
(Monad m, MetaTrace a) =>
Trace m a -> Trace m a
withSeverity (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\case
        (LoggingContext
lc, Right a
e)             -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (a -> Either TraceControl a
forall a b. b -> Either a b
Right a
e)
        (LoggingContext
lc, Left c :: TraceControl
c@(TCConfig TraceConfig
_)) -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
c)
        (LoggingContext
lc, Left d :: TraceControl
d@(TCDocument Int
_ DocCollector
_)) -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
d)
        (LoggingContext
lc, Left TraceControl
e)              -> (LoggingContext
lc, TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
e))
      Tracer m (LoggingContext, Either TraceControl a)
tr
  where
    process :: LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc cont :: Either a a
cont@(Right a
v) =
      if Maybe SeverityS -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe SeverityS
lcSeverity LoggingContext
lc)
        then (LoggingContext
lc, Either a a
cont)
        else (LoggingContext
lc {lcSeverity = severityFor (Namespace [] (lcNSInner lc) :: Namespace a) (Just v)}, Either a a
cont)
    process LoggingContext
lc cont :: Either a a
cont@(Left a
_) =
      if Maybe SeverityS -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe SeverityS
lcSeverity LoggingContext
lc)
        then (LoggingContext
lc, Either a a
cont)
        else (LoggingContext
lc {lcSeverity = severityFor (Namespace [] (lcNSInner lc) :: Namespace a) Nothing}, Either a a
cont)


allPublic :: a -> Privacy
allPublic :: forall a. a -> Privacy
allPublic a
_ = Privacy
Public

allConfidential :: a -> Privacy
allConfidential :: forall a. a -> Privacy
allConfidential a
_ = Privacy
Confidential

-- | Set 'Confidential' privacy on every message.
privately :: Monad m => Trace m a -> Trace m a
privately :: forall (m :: * -> *) a. Monad m => Trace m a -> Trace m a
privately = Privacy -> Trace m a -> Trace m a
forall (m :: * -> *) a.
Monad m =>
Privacy -> Trace m a -> Trace m a
setPrivacy Privacy
Confidential

-- | Set a fixed 'Privacy' on every message (no-op if already set).
setPrivacy :: Monad m => Privacy -> Trace m a -> Trace m a
setPrivacy :: forall (m :: * -> *) a.
Monad m =>
Privacy -> Trace m a -> Trace m a
setPrivacy Privacy
p (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) ->
          if Maybe Privacy -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe Privacy
lcPrivacy LoggingContext
lc)
            then (LoggingContext
lc, Either TraceControl a
cont)
            else (LoggingContext
lc {lcPrivacy = Just p}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Set privacy from the 'MetaTrace' instance for each message.
withPrivacy :: forall m a. (Monad m, MetaTrace a) => Trace m a -> Trace m a
withPrivacy :: forall (m :: * -> *) a.
(Monad m, MetaTrace a) =>
Trace m a -> Trace m a
withPrivacy (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\case
        (LoggingContext
lc, Right a
e)             -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (a -> Either TraceControl a
forall a b. b -> Either a b
Right a
e)
        (LoggingContext
lc, Left c :: TraceControl
c@(TCConfig TraceConfig
_)) -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
c)
        (LoggingContext
lc, Left d :: TraceControl
d@(TCDocument Int
_ DocCollector
_)) -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
d)
        (LoggingContext
lc, Left TraceControl
e)              -> (LoggingContext
lc, TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
e))
      Tracer m (LoggingContext, Either TraceControl a)
tr
  where
    process :: LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc cont :: Either a a
cont@(Right a
v) =
      if Maybe Privacy -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe Privacy
lcPrivacy LoggingContext
lc)
        then (LoggingContext
lc, Either a a
cont)
        else (LoggingContext
lc {lcPrivacy = privacyFor (Namespace [] (lcNSInner lc) :: Namespace a) (Just v)}, Either a a
cont)
    process LoggingContext
lc cont :: Either a a
cont@(Left a
_) =
      if Maybe Privacy -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe Privacy
lcPrivacy LoggingContext
lc)
        then (LoggingContext
lc, Either a a
cont)
        else (LoggingContext
lc {lcPrivacy = privacyFor (Namespace [] (lcNSInner lc) :: Namespace a) Nothing}, Either a a
cont)


-- | Set a fixed 'DetailLevel' on every message (no-op if already set).
setDetails :: Monad m => DetailLevel -> Trace m a -> Trace m a
setDetails :: forall (m :: * -> *) a.
Monad m =>
DetailLevel -> Trace m a -> Trace m a
setDetails DetailLevel
p (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) ->
          if Maybe DetailLevel -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe DetailLevel
lcDetails LoggingContext
lc)
            then (LoggingContext
lc, Either TraceControl a
cont)
            else (LoggingContext
lc {lcDetails = Just p}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Set detail level from the 'MetaTrace' instance for each message.
withDetails :: forall m a. (Monad m, MetaTrace a) => Trace m a -> Trace m a
withDetails :: forall (m :: * -> *) a.
(Monad m, MetaTrace a) =>
Trace m a -> Trace m a
withDetails (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\case
        (LoggingContext
lc, Right a
e)             -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (a -> Either TraceControl a
forall a b. b -> Either a b
Right a
e)
        (LoggingContext
lc, Left c :: TraceControl
c@(TCConfig TraceConfig
_)) -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
c)
        (LoggingContext
lc, Left d :: TraceControl
d@(TCDocument Int
_ DocCollector
_)) -> LoggingContext
-> Either TraceControl a -> (LoggingContext, Either TraceControl a)
forall {a}.
LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc (TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
d)
        (LoggingContext
lc, Left TraceControl
e)              -> (LoggingContext
lc, TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
e))
      Tracer m (LoggingContext, Either TraceControl a)
tr
  where
    process :: LoggingContext -> Either a a -> (LoggingContext, Either a a)
process LoggingContext
lc cont :: Either a a
cont@(Right a
v) =
      if Maybe DetailLevel -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe DetailLevel
lcDetails LoggingContext
lc)
        then (LoggingContext
lc, Either a a
cont)
        else (LoggingContext
lc {lcDetails = detailsFor (Namespace [] (lcNSInner lc) :: Namespace a) (Just v)}, Either a a
cont)
    process LoggingContext
lc cont :: Either a a
cont@(Left a
_) =
      if Maybe DetailLevel -> Bool
forall a. Maybe a -> Bool
isJust (LoggingContext -> Maybe DetailLevel
lcDetails LoggingContext
lc)
        then (LoggingContext
lc, Either a a
cont)
        else (LoggingContext
lc {lcDetails = detailsFor (Namespace [] (lcNSInner lc) :: Namespace a) Nothing}, Either a a
cont)


-- | Set prefix and inner namespace from the 'MetaTrace' instance for each
--   message, prepending the given prefix names.
{-# INLINE withNames #-}
withNames :: forall m a. (Monad m, MetaTrace a) => [Text] -> Trace m a -> Trace m a
withNames :: forall (m :: * -> *) a.
(Monad m, MetaTrace a) =>
[Text] -> Trace m a -> Trace m a
withNames [Text]
names (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\case
        (LoggingContext
lc, Right a
a) -> (LoggingContext
lc {lcNSPrefix = names,
                              lcNSInner  = nsInner (namespaceFor a)}, a -> Either TraceControl a
forall a b. b -> Either a b
Right a
a)
        (LoggingContext
lc, Left TraceControl
c)  -> (LoggingContext
lc {lcNSPrefix = names}, TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
c))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Set inner namespace from the 'MetaTrace' instance for each message.
{-# INLINE withInnerNames #-}
withInnerNames :: forall m a. (Monad m, MetaTrace a) => Trace m a -> Trace m a
withInnerNames :: forall (m :: * -> *) a.
(Monad m, MetaTrace a) =>
Trace m a -> Trace m a
withInnerNames (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\case
        (LoggingContext
lc, Right a
a) -> (LoggingContext
lc {lcNSInner = nsInner (namespaceFor a)}, a -> Either TraceControl a
forall a b. b -> Either a b
Right a
a)
        (LoggingContext
lc, Left TraceControl
c)  -> (LoggingContext
lc, TraceControl -> Either TraceControl a
forall a b. a -> Either a b
Left TraceControl
c))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Prepend a single name to the namespace prefix.
appendPrefixName :: Monad m => Text -> Trace m a -> Trace m a
appendPrefixName :: forall (m :: * -> *) a. Monad m => Text -> Trace m a -> Trace m a
appendPrefixName Text
name (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) -> (LoggingContext
lc {lcNSPrefix = name : lcNSPrefix lc}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

appendInnerName :: Monad m => Text -> Trace m a -> Trace m a
appendInnerName :: forall (m :: * -> *) a. Monad m => Text -> Trace m a -> Trace m a
appendInnerName Text
name (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) -> (LoggingContext
lc {lcNSInner = name : lcNSInner lc}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Prepend several names to the namespace prefix.
{-# INLINE appendPrefixNames #-}
appendPrefixNames :: Monad m => [Text] -> Trace m a -> Trace m a
appendPrefixNames :: forall (m :: * -> *) a. Monad m => [Text] -> Trace m a -> Trace m a
appendPrefixNames [Text]
names (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) -> (LoggingContext
lc {lcNSPrefix = names ++ lcNSPrefix lc}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

appendInnerNames :: Monad m => [Text] -> Trace m a -> Trace m a
appendInnerNames :: forall (m :: * -> *) a. Monad m => [Text] -> Trace m a -> Trace m a
appendInnerNames [Text]
names (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap
      (\(LoggingContext
lc, Either TraceControl a
cont) -> (LoggingContext
lc {lcNSInner = names ++ lcNSInner lc}, Either TraceControl a
cont))
      Tracer m (LoggingContext, Either TraceControl a)
tr

-- | Replace the logging context for all messages passing through this trace.
withLoggingContext :: Monad m => LoggingContext -> Trace m a -> Trace m a
withLoggingContext :: forall (m :: * -> *) a.
Monad m =>
LoggingContext -> Trace m a -> Trace m a
withLoggingContext LoggingContext
lc (Trace Tracer m (LoggingContext, Either TraceControl a)
tr) = Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall (m :: * -> *) a.
Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
Trace (Tracer m (LoggingContext, Either TraceControl a) -> Trace m a)
-> Tracer m (LoggingContext, Either TraceControl a) -> Trace m a
forall a b. (a -> b) -> a -> b
$
    ((LoggingContext, Either TraceControl a)
 -> (LoggingContext, Either TraceControl a))
-> Tracer m (LoggingContext, Either TraceControl a)
-> Tracer m (LoggingContext, Either TraceControl a)
forall a' a. (a' -> a) -> Tracer m a -> Tracer m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
T.contramap (\(LoggingContext
_lc, Either TraceControl a
cont) -> (LoggingContext
lc, Either TraceControl a
cont)) Tracer m (LoggingContext, Either TraceControl a)
tr