\subsection{Cardano.BM.Data.SubTrace}
\label{code:Cardano.BM.Data.SubTrace}

%if style == newcode
\begin{code}
{-# LANGUAGE CPP                  #-}
{-# LANGUAGE DeriveAnyClass       #-}
{-# LANGUAGE DeriveGeneric        #-}
{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

#if defined(mingw32_HOST_OS)
#define WINDOWS
#endif

module Cardano.BM.Data.SubTrace
  (
    SubTrace (..)
  , DropName (..), UnhideNames (..)
  , NameSelector (..)
#ifdef WINDOWS
  , ProcessID
#endif
  )
  where

#ifdef WINDOWS
import           System.Win32.Process (ProcessId)
#else
import           System.Posix.Types (ProcessID, CPid (..))
#endif
import           Data.Aeson (FromJSON (..), ToJSON (..), Value (..), (.:),
                     (.=), object, withObject)
import           Data.Text (Text, unpack)
import           GHC.Generics (Generic)

import           Cardano.BM.Data.LogItem (LoggerName)
import           Cardano.BM.Data.Observable
import           Cardano.BM.Data.Severity (Severity (..))

\end{code}
%endif

\subsubsection{SubTrace}\label{code:SubTrace}\index{SubTrace}
\label{code:Neutral}\index{SubTrace!Neutral}
\label{code:UntimedTrace}\index{SubTrace!UntimedTrace}
\label{code:NoTrace}\index{SubTrace!NoTrace}
\label{code:TeeTrace}\index{SubTrace!TeeTrace}
\label{code:FilterTrace}\index{SubTrace!FilterTrace}
\label{code:DropOpening}\index{SubTrace!DropOpening}
\label{code:ObservableTraceSelf}\index{SubTrace!ObservableTraceSelf}
\label{code:ObservableTrace}\index{SubTrace!ObservableTrace}
\label{code:SetSeverity}\index{SubTrace!SetSeverity}
\label{code:NameOperator}\index{SubTrace!FilterTrace!NameOperator}
\label{code:NameSelector}\index{SubTrace!FilterTrace!NameSelector}
\begin{code}
data NameSelector = Exact Text | StartsWith Text | EndsWith Text | Contains Text
                    deriving ((forall x. NameSelector -> Rep NameSelector x)
-> (forall x. Rep NameSelector x -> NameSelector)
-> Generic NameSelector
forall x. Rep NameSelector x -> NameSelector
forall x. NameSelector -> Rep NameSelector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameSelector x -> NameSelector
$cfrom :: forall x. NameSelector -> Rep NameSelector x
Generic, Int -> NameSelector -> ShowS
[NameSelector] -> ShowS
NameSelector -> String
(Int -> NameSelector -> ShowS)
-> (NameSelector -> String)
-> ([NameSelector] -> ShowS)
-> Show NameSelector
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NameSelector] -> ShowS
$cshowList :: [NameSelector] -> ShowS
show :: NameSelector -> String
$cshow :: NameSelector -> String
showsPrec :: Int -> NameSelector -> ShowS
$cshowsPrec :: Int -> NameSelector -> ShowS
Show, Value -> Parser [NameSelector]
Value -> Parser NameSelector
(Value -> Parser NameSelector)
-> (Value -> Parser [NameSelector]) -> FromJSON NameSelector
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NameSelector]
$cparseJSONList :: Value -> Parser [NameSelector]
parseJSON :: Value -> Parser NameSelector
$cparseJSON :: Value -> Parser NameSelector
FromJSON, [NameSelector] -> Encoding
[NameSelector] -> Value
NameSelector -> Encoding
NameSelector -> Value
(NameSelector -> Value)
-> (NameSelector -> Encoding)
-> ([NameSelector] -> Value)
-> ([NameSelector] -> Encoding)
-> ToJSON NameSelector
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NameSelector] -> Encoding
$ctoEncodingList :: [NameSelector] -> Encoding
toJSONList :: [NameSelector] -> Value
$ctoJSONList :: [NameSelector] -> Value
toEncoding :: NameSelector -> Encoding
$ctoEncoding :: NameSelector -> Encoding
toJSON :: NameSelector -> Value
$ctoJSON :: NameSelector -> Value
ToJSON, ReadPrec [NameSelector]
ReadPrec NameSelector
Int -> ReadS NameSelector
ReadS [NameSelector]
(Int -> ReadS NameSelector)
-> ReadS [NameSelector]
-> ReadPrec NameSelector
-> ReadPrec [NameSelector]
-> Read NameSelector
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NameSelector]
$creadListPrec :: ReadPrec [NameSelector]
readPrec :: ReadPrec NameSelector
$creadPrec :: ReadPrec NameSelector
readList :: ReadS [NameSelector]
$creadList :: ReadS [NameSelector]
readsPrec :: Int -> ReadS NameSelector
$creadsPrec :: Int -> ReadS NameSelector
Read, NameSelector -> NameSelector -> Bool
(NameSelector -> NameSelector -> Bool)
-> (NameSelector -> NameSelector -> Bool) -> Eq NameSelector
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameSelector -> NameSelector -> Bool
$c/= :: NameSelector -> NameSelector -> Bool
== :: NameSelector -> NameSelector -> Bool
$c== :: NameSelector -> NameSelector -> Bool
Eq)
data DropName     = Drop NameSelector
                    deriving ((forall x. DropName -> Rep DropName x)
-> (forall x. Rep DropName x -> DropName) -> Generic DropName
forall x. Rep DropName x -> DropName
forall x. DropName -> Rep DropName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DropName x -> DropName
$cfrom :: forall x. DropName -> Rep DropName x
Generic, Int -> DropName -> ShowS
[DropName] -> ShowS
DropName -> String
(Int -> DropName -> ShowS)
-> (DropName -> String) -> ([DropName] -> ShowS) -> Show DropName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DropName] -> ShowS
$cshowList :: [DropName] -> ShowS
show :: DropName -> String
$cshow :: DropName -> String
showsPrec :: Int -> DropName -> ShowS
$cshowsPrec :: Int -> DropName -> ShowS
Show, Value -> Parser [DropName]
Value -> Parser DropName
(Value -> Parser DropName)
-> (Value -> Parser [DropName]) -> FromJSON DropName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [DropName]
$cparseJSONList :: Value -> Parser [DropName]
parseJSON :: Value -> Parser DropName
$cparseJSON :: Value -> Parser DropName
FromJSON, [DropName] -> Encoding
[DropName] -> Value
DropName -> Encoding
DropName -> Value
(DropName -> Value)
-> (DropName -> Encoding)
-> ([DropName] -> Value)
-> ([DropName] -> Encoding)
-> ToJSON DropName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [DropName] -> Encoding
$ctoEncodingList :: [DropName] -> Encoding
toJSONList :: [DropName] -> Value
$ctoJSONList :: [DropName] -> Value
toEncoding :: DropName -> Encoding
$ctoEncoding :: DropName -> Encoding
toJSON :: DropName -> Value
$ctoJSON :: DropName -> Value
ToJSON, ReadPrec [DropName]
ReadPrec DropName
Int -> ReadS DropName
ReadS [DropName]
(Int -> ReadS DropName)
-> ReadS [DropName]
-> ReadPrec DropName
-> ReadPrec [DropName]
-> Read DropName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DropName]
$creadListPrec :: ReadPrec [DropName]
readPrec :: ReadPrec DropName
$creadPrec :: ReadPrec DropName
readList :: ReadS [DropName]
$creadList :: ReadS [DropName]
readsPrec :: Int -> ReadS DropName
$creadsPrec :: Int -> ReadS DropName
Read, DropName -> DropName -> Bool
(DropName -> DropName -> Bool)
-> (DropName -> DropName -> Bool) -> Eq DropName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DropName -> DropName -> Bool
$c/= :: DropName -> DropName -> Bool
== :: DropName -> DropName -> Bool
$c== :: DropName -> DropName -> Bool
Eq)
data UnhideNames  = Unhide [NameSelector]
                    deriving ((forall x. UnhideNames -> Rep UnhideNames x)
-> (forall x. Rep UnhideNames x -> UnhideNames)
-> Generic UnhideNames
forall x. Rep UnhideNames x -> UnhideNames
forall x. UnhideNames -> Rep UnhideNames x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UnhideNames x -> UnhideNames
$cfrom :: forall x. UnhideNames -> Rep UnhideNames x
Generic, Int -> UnhideNames -> ShowS
[UnhideNames] -> ShowS
UnhideNames -> String
(Int -> UnhideNames -> ShowS)
-> (UnhideNames -> String)
-> ([UnhideNames] -> ShowS)
-> Show UnhideNames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UnhideNames] -> ShowS
$cshowList :: [UnhideNames] -> ShowS
show :: UnhideNames -> String
$cshow :: UnhideNames -> String
showsPrec :: Int -> UnhideNames -> ShowS
$cshowsPrec :: Int -> UnhideNames -> ShowS
Show, Value -> Parser [UnhideNames]
Value -> Parser UnhideNames
(Value -> Parser UnhideNames)
-> (Value -> Parser [UnhideNames]) -> FromJSON UnhideNames
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [UnhideNames]
$cparseJSONList :: Value -> Parser [UnhideNames]
parseJSON :: Value -> Parser UnhideNames
$cparseJSON :: Value -> Parser UnhideNames
FromJSON, [UnhideNames] -> Encoding
[UnhideNames] -> Value
UnhideNames -> Encoding
UnhideNames -> Value
(UnhideNames -> Value)
-> (UnhideNames -> Encoding)
-> ([UnhideNames] -> Value)
-> ([UnhideNames] -> Encoding)
-> ToJSON UnhideNames
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [UnhideNames] -> Encoding
$ctoEncodingList :: [UnhideNames] -> Encoding
toJSONList :: [UnhideNames] -> Value
$ctoJSONList :: [UnhideNames] -> Value
toEncoding :: UnhideNames -> Encoding
$ctoEncoding :: UnhideNames -> Encoding
toJSON :: UnhideNames -> Value
$ctoJSON :: UnhideNames -> Value
ToJSON, ReadPrec [UnhideNames]
ReadPrec UnhideNames
Int -> ReadS UnhideNames
ReadS [UnhideNames]
(Int -> ReadS UnhideNames)
-> ReadS [UnhideNames]
-> ReadPrec UnhideNames
-> ReadPrec [UnhideNames]
-> Read UnhideNames
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UnhideNames]
$creadListPrec :: ReadPrec [UnhideNames]
readPrec :: ReadPrec UnhideNames
$creadPrec :: ReadPrec UnhideNames
readList :: ReadS [UnhideNames]
$creadList :: ReadS [UnhideNames]
readsPrec :: Int -> ReadS UnhideNames
$creadsPrec :: Int -> ReadS UnhideNames
Read, UnhideNames -> UnhideNames -> Bool
(UnhideNames -> UnhideNames -> Bool)
-> (UnhideNames -> UnhideNames -> Bool) -> Eq UnhideNames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnhideNames -> UnhideNames -> Bool
$c/= :: UnhideNames -> UnhideNames -> Bool
== :: UnhideNames -> UnhideNames -> Bool
$c== :: UnhideNames -> UnhideNames -> Bool
Eq)

data SubTrace = Neutral
              | UntimedTrace
              | NoTrace
              | TeeTrace LoggerName
              | FilterTrace [(DropName, UnhideNames)]
              | DropOpening
              | ObservableTraceSelf [ObservableInstance]
              | ObservableTrace ProcessID [ObservableInstance]
              | SetSeverity Severity
                deriving ((forall x. SubTrace -> Rep SubTrace x)
-> (forall x. Rep SubTrace x -> SubTrace) -> Generic SubTrace
forall x. Rep SubTrace x -> SubTrace
forall x. SubTrace -> Rep SubTrace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SubTrace x -> SubTrace
$cfrom :: forall x. SubTrace -> Rep SubTrace x
Generic, Int -> SubTrace -> ShowS
[SubTrace] -> ShowS
SubTrace -> String
(Int -> SubTrace -> ShowS)
-> (SubTrace -> String) -> ([SubTrace] -> ShowS) -> Show SubTrace
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubTrace] -> ShowS
$cshowList :: [SubTrace] -> ShowS
show :: SubTrace -> String
$cshow :: SubTrace -> String
showsPrec :: Int -> SubTrace -> ShowS
$cshowsPrec :: Int -> SubTrace -> ShowS
Show, ReadPrec [SubTrace]
ReadPrec SubTrace
Int -> ReadS SubTrace
ReadS [SubTrace]
(Int -> ReadS SubTrace)
-> ReadS [SubTrace]
-> ReadPrec SubTrace
-> ReadPrec [SubTrace]
-> Read SubTrace
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SubTrace]
$creadListPrec :: ReadPrec [SubTrace]
readPrec :: ReadPrec SubTrace
$creadPrec :: ReadPrec SubTrace
readList :: ReadS [SubTrace]
$creadList :: ReadS [SubTrace]
readsPrec :: Int -> ReadS SubTrace
$creadsPrec :: Int -> ReadS SubTrace
Read, SubTrace -> SubTrace -> Bool
(SubTrace -> SubTrace -> Bool)
-> (SubTrace -> SubTrace -> Bool) -> Eq SubTrace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubTrace -> SubTrace -> Bool
$c/= :: SubTrace -> SubTrace -> Bool
== :: SubTrace -> SubTrace -> Bool
$c== :: SubTrace -> SubTrace -> Bool
Eq)

#ifdef WINDOWS
-- Wrap the Win32 DWORD type alias so that it can be logged
newtype ProcessID = ProcessID ProcessId
    deriving (Generic, Show, Read, Eq)

instance ToJSON ProcessID where
    toJSON (ProcessID pid) = Number $ fromIntegral pid

instance FromJSON ProcessID where
    parseJSON v = ProcessID <$> parseJSON v
#else
instance ToJSON ProcessID where
    toJSON :: ProcessID -> Value
toJSON (CPid Int32
pid) = Scientific -> Value
Number (Scientific -> Value) -> Scientific -> Value
forall a b. (a -> b) -> a -> b
$ Int32 -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
pid

instance FromJSON ProcessID where
    parseJSON :: Value -> Parser ProcessID
parseJSON Value
v = Int32 -> ProcessID
CPid (Int32 -> ProcessID) -> Parser Int32 -> Parser ProcessID
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser Int32
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
#endif

instance FromJSON SubTrace where
    parseJSON :: Value -> Parser SubTrace
parseJSON = String -> (Object -> Parser SubTrace) -> Value -> Parser SubTrace
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SubTrace" ((Object -> Parser SubTrace) -> Value -> Parser SubTrace)
-> (Object -> Parser SubTrace) -> Value -> Parser SubTrace
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
                    Text
subtrace :: Text <- Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"subtrace"
                    case Text
subtrace of
                        Text
"Neutral"             -> SubTrace -> Parser SubTrace
forall (m :: * -> *) a. Monad m => a -> m a
return (SubTrace -> Parser SubTrace) -> SubTrace -> Parser SubTrace
forall a b. (a -> b) -> a -> b
$ SubTrace
Neutral
                        Text
"UntimedTrace"        -> SubTrace -> Parser SubTrace
forall (m :: * -> *) a. Monad m => a -> m a
return (SubTrace -> Parser SubTrace) -> SubTrace -> Parser SubTrace
forall a b. (a -> b) -> a -> b
$ SubTrace
UntimedTrace
                        Text
"NoTrace"             -> SubTrace -> Parser SubTrace
forall (m :: * -> *) a. Monad m => a -> m a
return (SubTrace -> Parser SubTrace) -> SubTrace -> Parser SubTrace
forall a b. (a -> b) -> a -> b
$ SubTrace
NoTrace
                        Text
"TeeTrace"            -> Text -> SubTrace
TeeTrace            (Text -> SubTrace) -> Parser Text -> Parser SubTrace
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"contents"
                        Text
"FilterTrace"         -> [(DropName, UnhideNames)] -> SubTrace
FilterTrace         ([(DropName, UnhideNames)] -> SubTrace)
-> Parser [(DropName, UnhideNames)] -> Parser SubTrace
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser [(DropName, UnhideNames)]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"contents"
                        Text
"DropOpening"         -> SubTrace -> Parser SubTrace
forall (m :: * -> *) a. Monad m => a -> m a
return (SubTrace -> Parser SubTrace) -> SubTrace -> Parser SubTrace
forall a b. (a -> b) -> a -> b
$ SubTrace
DropOpening
                        Text
"ObservableTraceSelf" -> [ObservableInstance] -> SubTrace
ObservableTraceSelf ([ObservableInstance] -> SubTrace)
-> Parser [ObservableInstance] -> Parser SubTrace
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser [ObservableInstance]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"contents"
                        Text
"ObservableTrace"     -> ProcessID -> [ObservableInstance] -> SubTrace
ObservableTrace     (ProcessID -> [ObservableInstance] -> SubTrace)
-> Parser ProcessID -> Parser ([ObservableInstance] -> SubTrace)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser ProcessID
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"pid"
                                                                     Parser ([ObservableInstance] -> SubTrace)
-> Parser [ObservableInstance] -> Parser SubTrace
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser [ObservableInstance]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"contents"
                        Text
"SetSeverity"         -> Severity -> SubTrace
SetSeverity         (Severity -> SubTrace) -> Parser Severity -> Parser SubTrace
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Severity
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"contents"
                        Text
other                 -> String -> Parser SubTrace
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser SubTrace) -> String -> Parser SubTrace
forall a b. (a -> b) -> a -> b
$ String
"unexpected subtrace: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ (Text -> String
unpack Text
other)

instance ToJSON SubTrace where
    toJSON :: SubTrace -> Value
toJSON SubTrace
Neutral =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"Neutral"             ]
    toJSON SubTrace
UntimedTrace =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"UntimedTrace"        ]
    toJSON SubTrace
NoTrace =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"NoTrace"             ]
    toJSON (TeeTrace Text
name) =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"TeeTrace"            , Text
"contents" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
name ]
    toJSON (FilterTrace [(DropName, UnhideNames)]
dus) =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"FilterTrace"         , Text
"contents" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [(DropName, UnhideNames)] -> Value
forall a. ToJSON a => a -> Value
toJSON [(DropName, UnhideNames)]
dus  ]
    toJSON SubTrace
DropOpening =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"DropOpening"         ]
    toJSON (ObservableTraceSelf [ObservableInstance]
os) =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"ObservableTraceSelf" , Text
"contents" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [ObservableInstance] -> Value
forall a. ToJSON a => a -> Value
toJSON [ObservableInstance]
os   ]
    toJSON (ObservableTrace ProcessID
pid [ObservableInstance]
os) =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"ObservableTrace"     , Text
"pid"      Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ProcessID -> Value
forall a. ToJSON a => a -> Value
toJSON ProcessID
pid
               , Text
"contents" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [ObservableInstance] -> Value
forall a. ToJSON a => a -> Value
toJSON [ObservableInstance]
os                    ]
    toJSON (SetSeverity Severity
sev) =
        [Pair] -> Value
object [ Text
"subtrace" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
String Text
"SetSeverity"         , Text
"contents" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Severity -> Value
forall a. ToJSON a => a -> Value
toJSON Severity
sev  ]

\end{code}