{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Node.Tracing.Documentation
  ( TraceDocumentationCmd (..)
  , parseTraceDocumentationCmd
  , runTraceDocumentationCmd
  , docTracers
  ) where

import           Data.Aeson.Types (ToJSON)
import qualified Data.Text.IO as T
import           Network.Mux (MuxTrace (..), WithMuxBearer (..))
import qualified Network.Socket as Socket
import qualified Options.Applicative as Opt

import           Cardano.Logging
import           Cardano.Logging.Resources
import           Cardano.Logging.Resources.Types
import           Cardano.Prelude hiding (trace)

import           Cardano.Node.Tracing.DefaultTraceConfig (defaultCardanoConfig)
import           Cardano.Node.Tracing.Formatting ()
import qualified Cardano.Node.Tracing.StateRep as SR
import           Cardano.Node.Tracing.Tracers.BlockReplayProgress
import           Cardano.Node.Tracing.Tracers.ChainDB
import           Cardano.Node.Tracing.Tracers.Consensus
import           Cardano.Node.Tracing.Tracers.Diffusion
import           Cardano.Node.Tracing.Tracers.ForgingThreadStats (
                   docForgeStats, forgeThreadStats)
import           Cardano.Node.Tracing.Tracers.KESInfo
import           Cardano.Node.Tracing.Tracers.NodeToClient
import           Cardano.Node.Tracing.Tracers.NodeToNode
import           Cardano.Node.Tracing.Tracers.NonP2P
import           Cardano.Node.Tracing.Tracers.P2P
import           Cardano.Node.Tracing.Tracers.Peer
import           Cardano.Node.Tracing.Tracers.Shutdown
import           Cardano.Node.Tracing.Tracers.Startup

import           Cardano.Node.Handlers.Shutdown (ShutdownTrace)
import           Cardano.Node.Startup
import           Cardano.Node.TraceConstraints

import           Ouroboros.Consensus.Block.Forging
import           Ouroboros.Consensus.BlockchainTime.WallClock.Types (RelativeTime)
import           Ouroboros.Consensus.BlockchainTime.WallClock.Util (TraceBlockchainTimeEvent (..))
import           Ouroboros.Consensus.Cardano.Block
import           Ouroboros.Consensus.Ledger.Inspect
import           Ouroboros.Consensus.Ledger.Query (Query, ShowQuery)
import           Ouroboros.Consensus.Ledger.SupportsMempool (ApplyTxErr, GenTxId,
                   LedgerSupportsMempool)
import           Ouroboros.Consensus.Ledger.SupportsProtocol
import           Ouroboros.Consensus.Mempool.API (TraceEventMempool (..))
import           Ouroboros.Consensus.MiniProtocol.BlockFetch.Server
                   (TraceBlockFetchServerEvent (..))
import           Ouroboros.Consensus.MiniProtocol.ChainSync.Client (TraceChainSyncClientEvent)
import           Ouroboros.Consensus.MiniProtocol.ChainSync.Server (TraceChainSyncServerEvent)
import           Ouroboros.Consensus.MiniProtocol.LocalTxSubmission.Server
                   (TraceLocalTxSubmissionServerEvent (..))
import           Ouroboros.Consensus.Node.NetworkProtocolVersion
import qualified Ouroboros.Consensus.Node.Run as Consensus
import qualified Ouroboros.Consensus.Node.Tracers as Consensus
import qualified Ouroboros.Consensus.Protocol.Ledger.HotKey as HotKey
import qualified Ouroboros.Consensus.Storage.ChainDB as ChainDB


import           Ouroboros.Network.Block (Point (..), SlotNo, Tip)
import qualified Ouroboros.Network.BlockFetch.ClientState as BlockFetch
import           Ouroboros.Network.BlockFetch.Decision
import           Ouroboros.Network.ConnectionHandler (ConnectionHandlerTrace (..))
import           Ouroboros.Network.ConnectionId (ConnectionId)
import           Ouroboros.Network.ConnectionManager.Types (ConnectionManagerTrace (..))
import qualified Ouroboros.Network.ConnectionManager.Types as ConnectionManager
import qualified Ouroboros.Network.Diffusion as Diffusion
import           Ouroboros.Network.Driver.Simple (TraceSendRecv)
import           Ouroboros.Network.InboundGovernor (InboundGovernorTrace)
import qualified Ouroboros.Network.InboundGovernor as InboundGovernor
import           Ouroboros.Network.KeepAlive (TraceKeepAliveClient (..))
import qualified Ouroboros.Network.NodeToClient as NtC
import           Ouroboros.Network.NodeToNode (ErrorPolicyTrace (..), RemoteAddress, WithAddr (..))
import qualified Ouroboros.Network.NodeToNode as NtN
import           Ouroboros.Network.PeerSelection.Governor (DebugPeerSelection (..),
                   PeerSelectionCounters (..), TracePeerSelection (..))
import           Ouroboros.Network.PeerSelection.LedgerPeers (TraceLedgerPeers)
import           Ouroboros.Network.PeerSelection.PeerStateActions (PeerSelectionActionsTrace (..))
import           Ouroboros.Network.PeerSelection.RootPeersDNS (TraceLocalRootPeers (..),
                   TracePublicRootPeers (..))
import           Ouroboros.Network.Protocol.BlockFetch.Type (BlockFetch)
import           Ouroboros.Network.Protocol.ChainSync.Type (ChainSync)
import           Ouroboros.Network.Protocol.Handshake.Unversioned (UnversionedProtocol (..),
                   UnversionedProtocolData (..))
import           Ouroboros.Network.Protocol.LocalStateQuery.Type (LocalStateQuery)
import qualified Ouroboros.Network.Protocol.LocalTxMonitor.Type as LTM
import qualified Ouroboros.Network.Protocol.LocalTxSubmission.Type as LTS
import           Ouroboros.Network.Protocol.TxSubmission2.Type (TxSubmission2)
import           Ouroboros.Network.Server2 (ServerTrace (..))
import           Ouroboros.Network.Snocket (LocalAddress (..))
import           Ouroboros.Network.Subscription.Dns (DnsTrace (..), WithDomainName (..))
import           Ouroboros.Network.Subscription.Ip (WithIPList (..))
import           Ouroboros.Network.Subscription.Worker (SubscriptionTrace (..))
import           Ouroboros.Network.TxSubmission.Inbound (TraceTxSubmissionInbound)
import           Ouroboros.Network.TxSubmission.Outbound (TraceTxSubmissionOutbound)

import           Cardano.Api.Orphans ()

data TraceDocumentationCmd
  = TraceDocumentationCmd
    { TraceDocumentationCmd -> FilePath
tdcConfigFile :: FilePath
    , TraceDocumentationCmd -> FilePath
tdcOutput     :: FilePath
    }

parseTraceDocumentationCmd :: Opt.Parser TraceDocumentationCmd
parseTraceDocumentationCmd :: Parser TraceDocumentationCmd
parseTraceDocumentationCmd =
  Mod CommandFields TraceDocumentationCmd
-> Parser TraceDocumentationCmd
forall a. Mod CommandFields a -> Parser a
Opt.subparser
    ([Mod CommandFields TraceDocumentationCmd]
-> Mod CommandFields TraceDocumentationCmd
forall a. Monoid a => [a] -> a
mconcat
     [ FilePath -> Mod CommandFields TraceDocumentationCmd
forall a. FilePath -> Mod CommandFields a
Opt.commandGroup FilePath
"Miscellaneous commands"
     , FilePath -> Mod CommandFields TraceDocumentationCmd
forall (f :: * -> *) a. HasMetavar f => FilePath -> Mod f a
Opt.metavar FilePath
"trace-documentation"
     , Mod CommandFields TraceDocumentationCmd
forall (f :: * -> *) a. Mod f a
Opt.hidden
     , FilePath
-> ParserInfo TraceDocumentationCmd
-> Mod CommandFields TraceDocumentationCmd
forall a. FilePath -> ParserInfo a -> Mod CommandFields a
Opt.command FilePath
"trace-documentation" (ParserInfo TraceDocumentationCmd
 -> Mod CommandFields TraceDocumentationCmd)
-> ParserInfo TraceDocumentationCmd
-> Mod CommandFields TraceDocumentationCmd
forall a b. (a -> b) -> a -> b
$
       Parser TraceDocumentationCmd
-> InfoMod TraceDocumentationCmd
-> ParserInfo TraceDocumentationCmd
forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info
         (FilePath -> FilePath -> TraceDocumentationCmd
TraceDocumentationCmd
           (FilePath -> FilePath -> TraceDocumentationCmd)
-> Parser FilePath -> Parser (FilePath -> TraceDocumentationCmd)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mod OptionFields FilePath -> Parser FilePath
forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
               ( FilePath -> Mod OptionFields FilePath
forall (f :: * -> *) a. HasName f => FilePath -> Mod f a
Opt.long FilePath
"config"
                 Mod OptionFields FilePath
-> Mod OptionFields FilePath -> Mod OptionFields FilePath
forall a. Semigroup a => a -> a -> a
<> FilePath -> Mod OptionFields FilePath
forall (f :: * -> *) a. HasMetavar f => FilePath -> Mod f a
Opt.metavar FilePath
"NODE-CONFIGURATION"
                 Mod OptionFields FilePath
-> Mod OptionFields FilePath -> Mod OptionFields FilePath
forall a. Semigroup a => a -> a -> a
<> FilePath -> Mod OptionFields FilePath
forall (f :: * -> *) a. FilePath -> Mod f a
Opt.help FilePath
"Configuration file for the cardano-node"
               )
           Parser (FilePath -> TraceDocumentationCmd)
-> Parser FilePath -> Parser TraceDocumentationCmd
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod OptionFields FilePath -> Parser FilePath
forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
               ( FilePath -> Mod OptionFields FilePath
forall (f :: * -> *) a. HasName f => FilePath -> Mod f a
Opt.long FilePath
"output-file"
                 Mod OptionFields FilePath
-> Mod OptionFields FilePath -> Mod OptionFields FilePath
forall a. Semigroup a => a -> a -> a
<> FilePath -> Mod OptionFields FilePath
forall (f :: * -> *) a. HasMetavar f => FilePath -> Mod f a
Opt.metavar FilePath
"FILE"
                 Mod OptionFields FilePath
-> Mod OptionFields FilePath -> Mod OptionFields FilePath
forall a. Semigroup a => a -> a -> a
<> FilePath -> Mod OptionFields FilePath
forall (f :: * -> *) a. FilePath -> Mod f a
Opt.help FilePath
"Generated documentation output file"
               )
           Parser TraceDocumentationCmd
-> Parser (TraceDocumentationCmd -> TraceDocumentationCmd)
-> Parser TraceDocumentationCmd
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
Opt.<**> Parser (TraceDocumentationCmd -> TraceDocumentationCmd)
forall a. Parser (a -> a)
Opt.helper)
       (InfoMod TraceDocumentationCmd -> ParserInfo TraceDocumentationCmd)
-> InfoMod TraceDocumentationCmd
-> ParserInfo TraceDocumentationCmd
forall a b. (a -> b) -> a -> b
$ [InfoMod TraceDocumentationCmd] -> InfoMod TraceDocumentationCmd
forall a. Monoid a => [a] -> a
mconcat [ FilePath -> InfoMod TraceDocumentationCmd
forall a. FilePath -> InfoMod a
Opt.progDesc FilePath
"Generate the trace documentation" ]
     ]
    )

deriving instance Generic UnversionedProtocol
deriving instance Generic UnversionedProtocolData

instance ToJSON UnversionedProtocol
instance ToJSON UnversionedProtocolData

runTraceDocumentationCmd
  :: TraceDocumentationCmd
  -> IO ()
runTraceDocumentationCmd :: TraceDocumentationCmd -> IO ()
runTraceDocumentationCmd TraceDocumentationCmd{FilePath
tdcOutput :: FilePath
tdcConfigFile :: FilePath
tdcOutput :: TraceDocumentationCmd -> FilePath
tdcConfigFile :: TraceDocumentationCmd -> FilePath
..} = do
  FilePath
-> FilePath
-> Proxy (CardanoBlock StandardCrypto)
-> Proxy (ConnectionId LocalAddress)
-> Proxy (ConnectionId RemoteAddress)
-> IO ()
forall blk peer remotePeer.
(TraceConstraints blk, InspectLedger blk,
 LedgerSupportsMempool blk, LedgerSupportsProtocol blk,
 SerialiseNodeToNodeConstraints blk, LogFormatting peer,
 LogFormatting remotePeer, Show (BlockNodeToClientVersion blk),
 Show (BlockNodeToNodeVersion blk), Show remotePeer, Show peer,
 Show (ForgeStateUpdateError blk), Show (CannotForge blk),
 ShowQuery (BlockQuery blk)) =>
FilePath
-> FilePath -> Proxy blk -> Proxy peer -> Proxy remotePeer -> IO ()
docTracers
    FilePath
tdcConfigFile FilePath
tdcOutput (Proxy (CardanoBlock StandardCrypto)
forall k (t :: k). Proxy t
Proxy @(CardanoBlock StandardCrypto))
                            (Proxy (ConnectionId LocalAddress)
forall k (t :: k). Proxy t
Proxy @(NtN.ConnectionId LocalAddress))
                            (Proxy (ConnectionId RemoteAddress)
forall k (t :: k). Proxy t
Proxy @(NtN.ConnectionId NtN.RemoteAddress))

-- Have to repeat the construction of the tracers here,
-- as the tracers are behind old tracer interface after construction in mkDispatchTracers.
-- Can be changed, when old tracers have gone
docTracers :: forall blk peer remotePeer.
  ( TraceConstraints blk
  , InspectLedger blk
  , LedgerSupportsMempool blk
  , LedgerSupportsProtocol blk
  , Consensus.SerialiseNodeToNodeConstraints blk
  , LogFormatting peer
  , LogFormatting remotePeer
  , Show (BlockNodeToClientVersion blk)
  , Show (BlockNodeToNodeVersion blk)
  , Show remotePeer
  , Show peer
  , Show (ForgeStateUpdateError blk)
  , Show (CannotForge blk)
  , ShowQuery (BlockQuery blk)
  )
  => FilePath
  -> FilePath
  -> Proxy blk
  -> Proxy peer
  -> Proxy remotePeer
  -> IO ()
docTracers :: FilePath
-> FilePath -> Proxy blk -> Proxy peer -> Proxy remotePeer -> IO ()
docTracers FilePath
configFileName FilePath
outputFileName Proxy blk
_ Proxy peer
_ Proxy remotePeer
_ = do
    TraceConfig
trConfig      <- FilePath -> TraceConfig -> IO TraceConfig
readConfigurationWithDefault FilePath
configFileName TraceConfig
defaultCardanoConfig
    let Trace IO FormattedMessage
trBase    :: Trace IO FormattedMessage = BackendConfig -> Trace IO FormattedMessage
forall (m :: * -> *).
MonadIO m =>
BackendConfig -> Trace m FormattedMessage
docTracer (FormatLogging -> BackendConfig
Stdout FormatLogging
MachineFormat)
        Trace IO FormattedMessage
trForward :: Trace IO FormattedMessage = BackendConfig -> Trace IO FormattedMessage
forall (m :: * -> *).
MonadIO m =>
BackendConfig -> Trace m FormattedMessage
docTracer BackendConfig
Forwarder
        trDataPoint :: Trace IO DataPoint
trDataPoint = BackendConfig -> Trace IO DataPoint
forall (m :: * -> *).
MonadIO m =>
BackendConfig -> Trace m DataPoint
docTracerDatapoint BackendConfig
DatapointBackend
        Maybe (Trace IO FormattedMessage)
mbTrEKG   :: Maybe (Trace IO FormattedMessage) = Trace IO FormattedMessage -> Maybe (Trace IO FormattedMessage)
forall a. a -> Maybe a
Just (BackendConfig -> Trace IO FormattedMessage
forall (m :: * -> *).
MonadIO m =>
BackendConfig -> Trace m FormattedMessage
docTracer BackendConfig
EKGBackend)
    -- NodeInfo tracer
    Trace IO NodeInfo
nodeInfoTr <- Trace IO DataPoint
-> (NodeInfo -> [Text]) -> IO (Trace IO NodeInfo)
forall dp.
ToJSON dp =>
Trace IO DataPoint -> (dp -> [Text]) -> IO (Trace IO dp)
mkDataPointTracer
                Trace IO DataPoint
trDataPoint
                ([Text] -> NodeInfo -> [Text]
forall a b. a -> b -> a
const [Text
"NodeInfo"])
    TraceConfig -> Documented NodeInfo -> [Trace IO NodeInfo] -> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented NodeInfo
docNodeInfoTraceEvent [Trace IO NodeInfo
nodeInfoTr]
    [([Text], DocuResult)]
nodeInfoTrDoc <- TraceConfig
-> Trace IO NodeInfo
-> Documented NodeInfo
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO NodeInfo
nodeInfoTr
      (Documented NodeInfo
docNodeInfoTraceEvent :: Documented NodeInfo)

    Trace IO NodeStartupInfo
nodeStartupInfoTr <- Trace IO DataPoint
-> (NodeStartupInfo -> [Text]) -> IO (Trace IO NodeStartupInfo)
forall dp.
ToJSON dp =>
Trace IO DataPoint -> (dp -> [Text]) -> IO (Trace IO dp)
mkDataPointTracer
                Trace IO DataPoint
trDataPoint
                ([Text] -> NodeStartupInfo -> [Text]
forall a b. a -> b -> a
const [Text
"NodeStartupInfo"])
    TraceConfig
-> Documented NodeStartupInfo
-> [Trace IO NodeStartupInfo]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented NodeStartupInfo
docNodeStartupInfoTraceEvent [Trace IO NodeStartupInfo
nodeStartupInfoTr]
    [([Text], DocuResult)]
nodeStartupInfoTrDoc <- TraceConfig
-> Trace IO NodeStartupInfo
-> Documented NodeStartupInfo
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO NodeStartupInfo
nodeStartupInfoTr
      (Documented NodeStartupInfo
docNodeStartupInfoTraceEvent :: Documented NodeStartupInfo)

    -- State tracer
    Trace IO NodeState
stateTr   <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (NodeState -> [Text])
-> (NodeState -> SeverityS)
-> (NodeState -> Privacy)
-> IO (Trace IO NodeState)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"NodeState"]
                NodeState -> [Text]
SR.namesNodeState
                NodeState -> SeverityS
SR.severityNodeState
                NodeState -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented NodeState -> [Trace IO NodeState] -> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented NodeState
SR.docNodeState [Trace IO NodeState
stateTr]
    [([Text], DocuResult)]
stateTrDoc <- TraceConfig
-> Trace IO NodeState
-> Documented NodeState
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO NodeState
stateTr
      (Documented NodeState
SR.docNodeState :: Documented SR.NodeState)

--  Peers tracer

    Trace IO [PeerT blk]
peersTr   <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> ([PeerT blk] -> [Text])
-> ([PeerT blk] -> SeverityS)
-> ([PeerT blk] -> Privacy)
-> IO (Trace IO [PeerT blk])
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Peers", Text
"List"]
                [PeerT blk] -> [Text]
forall blk. [PeerT blk] -> [Text]
namesForPeers
                [PeerT blk] -> SeverityS
forall blk. [PeerT blk] -> SeverityS
severityPeers
                [PeerT blk] -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented [PeerT blk] -> [Trace IO [PeerT blk]] -> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented [PeerT blk]
forall blk. Documented [PeerT blk]
docPeers [Trace IO [PeerT blk]
peersTr]
    [([Text], DocuResult)]
peersTrDoc <- TraceConfig
-> Trace IO [PeerT blk]
-> Documented [PeerT blk]
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO [PeerT blk]
peersTr
      (Documented [PeerT blk]
forall blk. Documented [PeerT blk]
docPeers :: Documented [PeerT blk])

    -- Resource tracer
    Trace IO ResourceStats
resourcesTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ResourceStats -> [Text])
-> (ResourceStats -> SeverityS)
-> (ResourceStats -> Privacy)
-> IO (Trace IO ResourceStats)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Resources"]
                ([Text] -> ResourceStats -> [Text]
forall a b. a -> b -> a
const [])
                (SeverityS -> ResourceStats -> SeverityS
forall a b. a -> b -> a
const SeverityS
Info)
                ResourceStats -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented ResourceStats -> [Trace IO ResourceStats] -> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented ResourceStats
docResourceStats [Trace IO ResourceStats
resourcesTr]
    [([Text], DocuResult)]
resourcesTrDoc <- TraceConfig
-> Trace IO ResourceStats
-> Documented ResourceStats
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO ResourceStats
resourcesTr
      (Documented ResourceStats
docResourceStats :: Documented ResourceStats)

    -- Startup tracer
    Trace IO (StartupTrace blk)
startupTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (StartupTrace blk -> [Text])
-> (StartupTrace blk -> SeverityS)
-> (StartupTrace blk -> Privacy)
-> IO (Trace IO (StartupTrace blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Startup"]
                StartupTrace blk -> [Text]
forall blk. StartupTrace blk -> [Text]
namesStartupInfo
                (SeverityS -> StartupTrace blk -> SeverityS
forall a b. a -> b -> a
const SeverityS
Notice)
                StartupTrace blk -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (StartupTrace blk)
-> [Trace IO (StartupTrace blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (StartupTrace blk)
forall blk. Documented (StartupTrace blk)
docStartupInfo [Trace IO (StartupTrace blk)
startupTr]
    [([Text], DocuResult)]
startupTrDoc <- TraceConfig
-> Trace IO (StartupTrace blk)
-> Documented (StartupTrace blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (StartupTrace blk)
startupTr
      (Documented (StartupTrace blk)
forall blk. Documented (StartupTrace blk)
docStartupInfo :: Documented (StartupTrace blk))

    Trace IO ShutdownTrace
shutdownTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ShutdownTrace -> [Text])
-> (ShutdownTrace -> SeverityS)
-> (ShutdownTrace -> Privacy)
-> IO (Trace IO ShutdownTrace)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Shutdown"]
                ShutdownTrace -> [Text]
namesForShutdown
                ShutdownTrace -> SeverityS
severityShutdown
                ShutdownTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented ShutdownTrace -> [Trace IO ShutdownTrace] -> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented ShutdownTrace
docShutdown [Trace IO ShutdownTrace
shutdownTr]
    [([Text], DocuResult)]
shutdownTrDoc <- TraceConfig
-> Trace IO ShutdownTrace
-> Documented ShutdownTrace
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO ShutdownTrace
shutdownTr
      (Documented ShutdownTrace
docShutdown :: Documented ShutdownTrace)




    Trace IO (TraceEvent blk)
chainDBTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceEvent blk -> [Text])
-> (TraceEvent blk -> SeverityS)
-> (TraceEvent blk -> Privacy)
-> (Trace IO (TraceEvent blk) -> IO (Trace IO (TraceEvent blk)))
-> IO (Trace IO (TraceEvent blk))
forall evt evt1.
LogFormatting evt1 =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt1 -> [Text])
-> (evt1 -> SeverityS)
-> (evt1 -> Privacy)
-> (Trace IO evt1 -> IO (Trace IO evt))
-> IO (Trace IO evt)
mkCardanoTracer'
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"ChainDB"]
                TraceEvent blk -> [Text]
forall blk. TraceEvent blk -> [Text]
namesForChainDBTraceEvents
                TraceEvent blk -> SeverityS
forall blk. TraceEvent blk -> SeverityS
severityChainDB
                TraceEvent blk -> Privacy
forall a. a -> Privacy
allPublic
                Trace IO (TraceEvent blk) -> IO (Trace IO (TraceEvent blk))
forall blk.
Trace IO (TraceEvent blk) -> IO (Trace IO (TraceEvent blk))
withAddedToCurrentChainEmptyLimited
    TraceConfig
-> Documented (TraceEvent blk)
-> [Trace IO (TraceEvent blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceEvent blk)
forall blk. Documented (TraceEvent blk)
docChainDBTraceEvent [Trace IO (TraceEvent blk)
chainDBTr]
    [([Text], DocuResult)]
chainDBTrDoc <- TraceConfig
-> Trace IO (TraceEvent blk)
-> Documented (TraceEvent blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceEvent blk)
chainDBTr
      (Documented (TraceEvent blk)
forall blk. Documented (TraceEvent blk)
docChainDBTraceEvent :: Documented (ChainDB.TraceEvent blk))

    Trace IO ReplayBlockStats
replayBlockTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ReplayBlockStats -> [Text])
-> (ReplayBlockStats -> SeverityS)
-> (ReplayBlockStats -> Privacy)
-> IO (Trace IO ReplayBlockStats)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"ChainDB", Text
"ReplayBlock"]
                ReplayBlockStats -> [Text]
namesForReplayBlockStats
                ReplayBlockStats -> SeverityS
severityReplayBlockStats
                ReplayBlockStats -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented ReplayBlockStats
-> [Trace IO ReplayBlockStats]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented ReplayBlockStats
docReplayedBlock [Trace IO ReplayBlockStats
replayBlockTr]
    [([Text], DocuResult)]
replayBlockTrDoc <- TraceConfig
-> Trace IO ReplayBlockStats
-> Documented ReplayBlockStats
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO ReplayBlockStats
replayBlockTr
      (Documented ReplayBlockStats
docReplayedBlock :: Documented ReplayBlockStats)

-- Consensus tracers

    Trace
  IO
  (TraceLabelPeer
     (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
chainSyncClientTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)
    -> [Text])
-> (TraceLabelPeer
      (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)
    -> SeverityS)
-> (TraceLabelPeer
      (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"ChainSync", Text
"Client"]
                TraceLabelPeer
  (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)
-> [Text]
forall peer blk.
TraceLabelPeer peer (TraceChainSyncClientEvent blk) -> [Text]
namesForChainSyncClientEvent
                TraceLabelPeer
  (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)
-> SeverityS
forall peer blk.
TraceLabelPeer peer (TraceChainSyncClientEvent blk) -> SeverityS
severityChainSyncClientEvent
                TraceLabelPeer
  (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk)
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
-> [Trace
      IO
      (TraceLabelPeer
         (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
forall peer blk.
Documented (TraceLabelPeer peer (TraceChainSyncClientEvent blk))
docChainSyncClientEvent [Trace
  IO
  (TraceLabelPeer
     (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
chainSyncClientTr]
    [([Text], DocuResult)]
chainSyncClientTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
-> Documented
     (TraceLabelPeer
        (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
chainSyncClientTr
      (Documented
  (TraceLabelPeer
     (ConnectionId RemoteAddress) (TraceChainSyncClientEvent blk))
forall peer blk.
Documented (TraceLabelPeer peer (TraceChainSyncClientEvent blk))
docChainSyncClientEvent :: Documented (BlockFetch.TraceLabelPeer
                                    (ConnectionId RemoteAddress)
                                    (TraceChainSyncClientEvent blk)))

    Trace IO (TraceChainSyncServerEvent blk)
chainSyncServerHeaderTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceChainSyncServerEvent blk -> [Text])
-> (TraceChainSyncServerEvent blk -> SeverityS)
-> (TraceChainSyncServerEvent blk -> Privacy)
-> IO (Trace IO (TraceChainSyncServerEvent blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"ChainSync", Text
"ServerHeader"]
                TraceChainSyncServerEvent blk -> [Text]
forall blk. TraceChainSyncServerEvent blk -> [Text]
namesForChainSyncServerEvent
                TraceChainSyncServerEvent blk -> SeverityS
forall blk. TraceChainSyncServerEvent blk -> SeverityS
severityChainSyncServerEvent
                TraceChainSyncServerEvent blk -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceChainSyncServerEvent blk)
-> [Trace IO (TraceChainSyncServerEvent blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceChainSyncServerEvent blk)
forall blk. Documented (TraceChainSyncServerEvent blk)
docChainSyncServerEventHeader [Trace IO (TraceChainSyncServerEvent blk)
chainSyncServerHeaderTr]
    [([Text], DocuResult)]
chainSyncServerHeaderTrDoc <- TraceConfig
-> Trace IO (TraceChainSyncServerEvent blk)
-> Documented (TraceChainSyncServerEvent blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceChainSyncServerEvent blk)
chainSyncServerHeaderTr
      (Documented (TraceChainSyncServerEvent blk)
forall blk. Documented (TraceChainSyncServerEvent blk)
docChainSyncServerEventHeader :: Documented (TraceChainSyncServerEvent blk))

    Trace IO (TraceChainSyncServerEvent blk)
chainSyncServerBlockTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceChainSyncServerEvent blk -> [Text])
-> (TraceChainSyncServerEvent blk -> SeverityS)
-> (TraceChainSyncServerEvent blk -> Privacy)
-> IO (Trace IO (TraceChainSyncServerEvent blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"ChainSync", Text
"ServerBlock"]
                TraceChainSyncServerEvent blk -> [Text]
forall blk. TraceChainSyncServerEvent blk -> [Text]
namesForChainSyncServerEvent
                TraceChainSyncServerEvent blk -> SeverityS
forall blk. TraceChainSyncServerEvent blk -> SeverityS
severityChainSyncServerEvent
                TraceChainSyncServerEvent blk -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceChainSyncServerEvent blk)
-> [Trace IO (TraceChainSyncServerEvent blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceChainSyncServerEvent blk)
forall blk. Documented (TraceChainSyncServerEvent blk)
docChainSyncServerEventBlock [Trace IO (TraceChainSyncServerEvent blk)
chainSyncServerBlockTr]
    [([Text], DocuResult)]
chainSyncServerBlockTrDoc <- TraceConfig
-> Trace IO (TraceChainSyncServerEvent blk)
-> Documented (TraceChainSyncServerEvent blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceChainSyncServerEvent blk)
chainSyncServerBlockTr
      (Documented (TraceChainSyncServerEvent blk)
forall blk. Documented (TraceChainSyncServerEvent blk)
docChainSyncServerEventBlock :: Documented (TraceChainSyncServerEvent blk))

    Trace
  IO [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
blockFetchDecisionTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> ([TraceLabelPeer
       remotePeer (FetchDecision [Point (Header blk)])]
    -> [Text])
-> ([TraceLabelPeer
       remotePeer (FetchDecision [Point (Header blk)])]
    -> SeverityS)
-> ([TraceLabelPeer
       remotePeer (FetchDecision [Point (Header blk)])]
    -> Privacy)
-> IO
     (Trace
        IO
        [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])])
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"BlockFetch", Text
"Decision"]
                [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
-> [Text]
forall peer header.
[TraceLabelPeer peer (FetchDecision [Point header])] -> [Text]
namesForBlockFetchDecision
                [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
-> SeverityS
forall peer header.
[TraceLabelPeer peer (FetchDecision [Point header])] -> SeverityS
severityBlockFetchDecision
                [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
-> Privacy
forall a. a -> Privacy
allConfidential
    TraceConfig
-> Documented
     [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
-> [Trace
      IO
      [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
forall remotePeer blk.
Documented
  [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
docBlockFetchDecision [Trace
  IO [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
blockFetchDecisionTr]
    [([Text], DocuResult)]
blockFetchDecisionTrDoc <- TraceConfig
-> Trace
     IO [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
-> Documented
     [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
blockFetchDecisionTr
      (Documented
  [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
forall remotePeer blk.
Documented
  [TraceLabelPeer remotePeer (FetchDecision [Point (Header blk)])]
docBlockFetchDecision :: Documented [BlockFetch.TraceLabelPeer
                                      remotePeer
                                      (FetchDecision [Point (Header blk)])])

    Trace
  IO (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
blockFetchClientTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))
    -> [Text])
-> (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))
    -> SeverityS)
-> (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"BlockFetch", Text
"Client"]
                TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))
-> [Text]
forall peer header.
TraceLabelPeer peer (TraceFetchClientState header) -> [Text]
namesForBlockFetchClient
                TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))
-> SeverityS
forall peer header.
TraceLabelPeer peer (TraceFetchClientState header) -> SeverityS
severityBlockFetchClient
                TraceLabelPeer remotePeer (TraceFetchClientState (Header blk))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
-> [Trace
      IO
      (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
forall remotePeer blk.
Documented
  (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
docBlockFetchClient [Trace
  IO (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
blockFetchClientTr]
    [([Text], DocuResult)]
blockFetchClientTrDoc <- TraceConfig
-> Trace
     IO (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
-> Documented
     (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
blockFetchClientTr
      (Documented
  (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
forall remotePeer blk.
Documented
  (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
docBlockFetchClient :: Documented (BlockFetch.TraceLabelPeer
                                remotePeer
                                (BlockFetch.TraceFetchClientState (Header blk))))

    [([Text], DocuResult)]
clientMetricsDoc <- TraceConfig
-> Trace
     IO (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
-> Documented
     (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
blockFetchClientTr
      (Documented
  (TraceLabelPeer remotePeer (TraceFetchClientState (Header blk)))
forall peer header.
Documented (TraceLabelPeer peer (TraceFetchClientState header))
docBlockFetchClientMetrics :: Documented (BlockFetch.TraceLabelPeer
                                remotePeer
                                (BlockFetch.TraceFetchClientState (Header blk))))


    Trace IO (TraceBlockFetchServerEvent blk)
blockFetchServerTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceBlockFetchServerEvent blk -> [Text])
-> (TraceBlockFetchServerEvent blk -> SeverityS)
-> (TraceBlockFetchServerEvent blk -> Privacy)
-> IO (Trace IO (TraceBlockFetchServerEvent blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"BlockFetch", Text
"Server"]
                TraceBlockFetchServerEvent blk -> [Text]
forall blk. TraceBlockFetchServerEvent blk -> [Text]
namesForBlockFetchServer
                TraceBlockFetchServerEvent blk -> SeverityS
forall blk. TraceBlockFetchServerEvent blk -> SeverityS
severityBlockFetchServer
                TraceBlockFetchServerEvent blk -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceBlockFetchServerEvent blk)
-> [Trace IO (TraceBlockFetchServerEvent blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceBlockFetchServerEvent blk)
forall blk. Documented (TraceBlockFetchServerEvent blk)
docBlockFetchServer [Trace IO (TraceBlockFetchServerEvent blk)
blockFetchServerTr]
    [([Text], DocuResult)]
blockFetchServerTrDoc <- TraceConfig
-> Trace IO (TraceBlockFetchServerEvent blk)
-> Documented (TraceBlockFetchServerEvent blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceBlockFetchServerEvent blk)
blockFetchServerTr
      (Documented (TraceBlockFetchServerEvent blk)
forall blk. Documented (TraceBlockFetchServerEvent blk)
docBlockFetchServer :: Documented (TraceBlockFetchServerEvent blk))

    Trace IO (TraceLabelCreds KESInfo)
forgeKESInfoTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelCreds KESInfo -> [Text])
-> (TraceLabelCreds KESInfo -> SeverityS)
-> (TraceLabelCreds KESInfo -> Privacy)
-> IO (Trace IO (TraceLabelCreds KESInfo))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Forge", Text
"KESInfo"]
                TraceLabelCreds KESInfo -> [Text]
namesForKESInfo
                TraceLabelCreds KESInfo -> SeverityS
severityKESInfo
                TraceLabelCreds KESInfo -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceLabelCreds KESInfo)
-> [Trace IO (TraceLabelCreds KESInfo)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceLabelCreds KESInfo)
docForgeKESInfo [Trace IO (TraceLabelCreds KESInfo)
forgeKESInfoTr]
    [([Text], DocuResult)]
forgeKESInfoTrDoc <- TraceConfig
-> Trace IO (TraceLabelCreds KESInfo)
-> Documented (TraceLabelCreds KESInfo)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceLabelCreds KESInfo)
forgeKESInfoTr
      (Documented (TraceLabelCreds KESInfo)
docForgeKESInfo :: Documented (Consensus.TraceLabelCreds HotKey.KESInfo))

    Trace
  IO
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
txInboundTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))
    -> [Text])
-> (TraceLabelPeer
      remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))
    -> SeverityS)
-> (TraceLabelPeer
      remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"TxSubmission", Text
"TxInbound"]
                TraceLabelPeer
  remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer (TraceTxSubmissionInbound (GenTxId blk) (GenTx blk))
-> [Text]
namesForTxInbound
                TraceLabelPeer
  remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer (TraceTxSubmissionInbound (GenTxId blk) (GenTx blk))
-> SeverityS
severityTxInbound
                TraceLabelPeer
  remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
-> [Trace
      IO
      (TraceLabelPeer
         remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
forall remotePeer txid tx.
Documented
  (TraceLabelPeer remotePeer (TraceTxSubmissionInbound txid tx))
docTxInbound [Trace
  IO
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
txInboundTr]
    [([Text], DocuResult)]
txInboundTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
-> Documented
     (TraceLabelPeer
        remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionInbound (GenTxId Any) (GenTx Any)))
txInboundTr
      (forall txid tx.
Documented
  (TraceLabelPeer remotePeer (TraceTxSubmissionInbound txid tx))
forall remotePeer txid tx.
Documented
  (TraceLabelPeer remotePeer (TraceTxSubmissionInbound txid tx))
docTxInbound :: Documented (BlockFetch.TraceLabelPeer
                                    remotePeer
                                    (TraceTxSubmissionInbound txid tx)))

    Trace
  IO
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
txOutboundTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
    -> [Text])
-> (TraceLabelPeer
      remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
    -> SeverityS)
-> (TraceLabelPeer
      remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"TxSubmission", Text
"TxOutbound"]
                TraceLabelPeer
  remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
-> [Text]
namesForTxOutbound
                TraceLabelPeer
  remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
-> SeverityS
severityTxOutbound
                TraceLabelPeer
  remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
-> [Trace
      IO
      (TraceLabelPeer
         remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
forall remotePeer txid tx.
Documented
  (TraceLabelPeer remotePeer (TraceTxSubmissionOutbound txid tx))
docTxOutbound [Trace
  IO
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
txOutboundTr]
    [([Text], DocuResult)]
txOutboundTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
-> Documented
     (TraceLabelPeer
        remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionOutbound (GenTxId blk) (GenTx blk)))
txOutboundTr
      (forall tx.
Documented
  (TraceLabelPeer
     remotePeer (TraceTxSubmissionOutbound (GenTxId blk) tx))
forall remotePeer txid tx.
Documented
  (TraceLabelPeer remotePeer (TraceTxSubmissionOutbound txid tx))
docTxOutbound :: Documented (BlockFetch.TraceLabelPeer
                            remotePeer
                            (TraceTxSubmissionOutbound (TxId (GenTx blk)) tx)))

    Trace IO (TraceLocalTxSubmissionServerEvent blk)
localTxSubmissionServerTr <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLocalTxSubmissionServerEvent blk -> [Text])
-> (TraceLocalTxSubmissionServerEvent blk -> SeverityS)
-> (TraceLocalTxSubmissionServerEvent blk -> Privacy)
-> IO (Trace IO (TraceLocalTxSubmissionServerEvent blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"TxSubmission", Text
"LocalServer"]
                TraceLocalTxSubmissionServerEvent blk -> [Text]
forall blk. TraceLocalTxSubmissionServerEvent blk -> [Text]
namesForLocalTxSubmissionServer
                TraceLocalTxSubmissionServerEvent blk -> SeverityS
forall blk. TraceLocalTxSubmissionServerEvent blk -> SeverityS
severityLocalTxSubmissionServer
                TraceLocalTxSubmissionServerEvent blk -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceLocalTxSubmissionServerEvent blk)
-> [Trace IO (TraceLocalTxSubmissionServerEvent blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceLocalTxSubmissionServerEvent blk)
forall blk. Documented (TraceLocalTxSubmissionServerEvent blk)
docLocalTxSubmissionServer [Trace IO (TraceLocalTxSubmissionServerEvent blk)
localTxSubmissionServerTr]
    [([Text], DocuResult)]
localTxSubmissionServerTrDoc <- TraceConfig
-> Trace IO (TraceLocalTxSubmissionServerEvent blk)
-> Documented (TraceLocalTxSubmissionServerEvent blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceLocalTxSubmissionServerEvent blk)
localTxSubmissionServerTr
      (Documented (TraceLocalTxSubmissionServerEvent blk)
forall blk. Documented (TraceLocalTxSubmissionServerEvent blk)
docLocalTxSubmissionServer :: Documented (TraceLocalTxSubmissionServerEvent blk))


    Trace IO (TraceEventMempool blk)
mempoolTr   <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceEventMempool blk -> [Text])
-> (TraceEventMempool blk -> SeverityS)
-> (TraceEventMempool blk -> Privacy)
-> IO (Trace IO (TraceEventMempool blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Mempool"]
                TraceEventMempool blk -> [Text]
forall blk. TraceEventMempool blk -> [Text]
namesForMempool
                TraceEventMempool blk -> SeverityS
forall blk. TraceEventMempool blk -> SeverityS
severityMempool
                TraceEventMempool blk -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceEventMempool blk)
-> [Trace IO (TraceEventMempool blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceEventMempool blk)
forall blk. Documented (TraceEventMempool blk)
docMempool [Trace IO (TraceEventMempool blk)
mempoolTr]
    [([Text], DocuResult)]
mempoolTrDoc <- TraceConfig
-> Trace IO (TraceEventMempool blk)
-> Documented (TraceEventMempool blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceEventMempool blk)
mempoolTr
      (Documented (TraceEventMempool blk)
forall blk. Documented (TraceEventMempool blk)
docMempool :: Documented (TraceEventMempool blk))

    Trace IO (ForgeTracerType blk)
forgeTr <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ForgeTracerType blk -> [Text])
-> (ForgeTracerType blk -> SeverityS)
-> (ForgeTracerType blk -> Privacy)
-> IO (Trace IO (ForgeTracerType blk))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Forge", Text
"Loop"]
                ForgeTracerType blk -> [Text]
forall blk. ForgeTracerType blk -> [Text]
namesForForge
                ForgeTracerType blk -> SeverityS
forall blk. ForgeTracerType blk -> SeverityS
severityForge
                ForgeTracerType blk -> Privacy
forall a. a -> Privacy
allPublic

    -- TODO Tracers docforgeThreadStatsTr?
    Trace IO (ForgeTracerType blk)
forgeThreadStatsTr <-
                Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ForgingStats -> [Text])
-> (ForgingStats -> SeverityS)
-> (ForgingStats -> Privacy)
-> (Trace IO ForgingStats -> IO (Trace IO (ForgeTracerType blk)))
-> IO (Trace IO (ForgeTracerType blk))
forall evt evt1.
LogFormatting evt1 =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt1 -> [Text])
-> (evt1 -> SeverityS)
-> (evt1 -> Privacy)
-> (Trace IO evt1 -> IO (Trace IO evt))
-> IO (Trace IO evt)
mkCardanoTracer'
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Forge", Text
"Stats"]
                ForgingStats -> [Text]
namesForForge2
                ForgingStats -> SeverityS
severityForge2
                ForgingStats -> Privacy
forall a. a -> Privacy
allPublic
                Trace IO ForgingStats -> IO (Trace IO (ForgeTracerType blk))
forall blk.
Trace IO ForgingStats -> IO (Trace IO (ForgeTracerType blk))
forgeThreadStats

    TraceConfig
-> Documented (ForgeTracerType blk)
-> [Trace IO (ForgeTracerType blk)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (ForgeTracerType blk)
forall blk.
Documented
  (Either (TraceForgeEvent blk) TraceStartLeadershipCheckPlus)
docForge [Trace IO (ForgeTracerType blk)
forgeTr, Trace IO (ForgeTracerType blk)
forgeThreadStatsTr]
    [([Text], DocuResult)]
forgeTrDoc <- TraceConfig
-> Trace IO (ForgeTracerType blk)
-> Documented (ForgeTracerType blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (ForgeTracerType blk)
forgeTr
      (Documented (ForgeTracerType blk)
forall blk.
Documented
  (Either (TraceForgeEvent blk) TraceStartLeadershipCheckPlus)
docForge :: Documented (Either (Consensus.TraceForgeEvent blk)
                               TraceStartLeadershipCheckPlus))

    [([Text], DocuResult)]
forgeThreadStatsTrDoc <- TraceConfig
-> Trace IO (ForgeTracerType blk)
-> Documented (ForgeTracerType blk)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (ForgeTracerType blk)
forgeThreadStatsTr
      (Documented (ForgeTracerType blk)
forall blk.
Documented
  (Either (TraceForgeEvent blk) TraceStartLeadershipCheckPlus)
docForgeStats :: Documented (Either (Consensus.TraceForgeEvent blk)
                               TraceStartLeadershipCheckPlus))

    Trace IO (TraceBlockchainTimeEvent RelativeTime)
blockchainTimeTr   <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceBlockchainTimeEvent RelativeTime -> [Text])
-> (TraceBlockchainTimeEvent RelativeTime -> SeverityS)
-> (TraceBlockchainTimeEvent RelativeTime -> Privacy)
-> IO (Trace IO (TraceBlockchainTimeEvent RelativeTime))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"BlockchainTime"]
                TraceBlockchainTimeEvent RelativeTime -> [Text]
forall t. TraceBlockchainTimeEvent t -> [Text]
namesForBlockchainTime
                TraceBlockchainTimeEvent RelativeTime -> SeverityS
forall t. TraceBlockchainTimeEvent t -> SeverityS
severityBlockchainTime
                TraceBlockchainTimeEvent RelativeTime -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceBlockchainTimeEvent RelativeTime)
-> [Trace IO (TraceBlockchainTimeEvent RelativeTime)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceBlockchainTimeEvent RelativeTime)
forall t. Documented (TraceBlockchainTimeEvent t)
docBlockchainTime [Trace IO (TraceBlockchainTimeEvent RelativeTime)
blockchainTimeTr]
    [([Text], DocuResult)]
blockchainTimeTrDoc <- TraceConfig
-> Trace IO (TraceBlockchainTimeEvent RelativeTime)
-> Documented (TraceBlockchainTimeEvent RelativeTime)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceBlockchainTimeEvent RelativeTime)
blockchainTimeTr
      (Documented (TraceBlockchainTimeEvent RelativeTime)
forall t. Documented (TraceBlockchainTimeEvent t)
docBlockchainTime :: Documented (TraceBlockchainTimeEvent RelativeTime))

-- Node to client

    Trace IO (TraceKeepAliveClient peer)
keepAliveClientTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceKeepAliveClient peer -> [Text])
-> (TraceKeepAliveClient peer -> SeverityS)
-> (TraceKeepAliveClient peer -> Privacy)
-> IO (Trace IO (TraceKeepAliveClient peer))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"KeepAliveClient"]
                TraceKeepAliveClient peer -> [Text]
forall peer. TraceKeepAliveClient peer -> [Text]
namesForKeepAliveClient
                TraceKeepAliveClient peer -> SeverityS
forall peer. TraceKeepAliveClient peer -> SeverityS
severityKeepAliveClient
                TraceKeepAliveClient peer -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceKeepAliveClient peer)
-> [Trace IO (TraceKeepAliveClient peer)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceKeepAliveClient peer)
forall peer. Documented (TraceKeepAliveClient peer)
docKeepAliveClient [Trace IO (TraceKeepAliveClient peer)
keepAliveClientTr]
    [([Text], DocuResult)]
keepAliveClientTrDoc <- TraceConfig
-> Trace IO (TraceKeepAliveClient peer)
-> Documented (TraceKeepAliveClient peer)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceKeepAliveClient peer)
keepAliveClientTr
      (Documented (TraceKeepAliveClient peer)
forall peer. Documented (TraceKeepAliveClient peer)
docKeepAliveClient :: Documented (TraceKeepAliveClient peer))

    Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
chainSyncTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer
      (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
    -> [Text])
-> (TraceLabelPeer
      peer
      (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer
      (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer
           (TraceSendRecv
              (ChainSync (Serialised blk) (Point blk) (Tip blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                 [Text
"ChainSync", Text
"Local"]
                TraceLabelPeer
  peer
  (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
-> [Text]
namesForTChainSync
                TraceLabelPeer
  peer
  (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
-> SeverityS
severityTChainSync
                TraceLabelPeer
  peer
  (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer
         (TraceSendRecv
            (ChainSync (Serialised blk) (Point blk) (Tip blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
forall peer x blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
docTChainSyncNodeToClient [Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
chainSyncTr]
    [([Text], DocuResult)]
chainSyncTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer
        (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Serialised blk) (Point blk) (Tip blk))))
chainSyncTr
      (forall x.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
forall peer x blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
docTChainSyncNodeToClient :: Documented
        (BlockFetch.TraceLabelPeer peer (TraceSendRecv
          (ChainSync x (Point blk) (Tip blk)))))

    Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
txMonitorTr <-
      Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer
      (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
    -> [Text])
-> (TraceLabelPeer
      peer
      (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
    -> SeverityS)
-> (TraceLabelPeer
      peer
      (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer
           (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
        Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
        [Text
"TxSubmission", Text
"MonitorClient"]
        TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
-> [Text]
namesForTTxMonitor
        TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
-> SeverityS
severityTTxMonitor
        TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
-> [Trace
      IO
      (TraceLabelPeer
         peer
         (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
forall localPeer blk.
Documented
  (TraceLabelPeer
     localPeer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
docTTxMonitor [Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
txMonitorTr]
    [([Text], DocuResult)]
txMonitorTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer
        (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
txMonitorTr
      (Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
forall localPeer blk.
Documented
  (TraceLabelPeer
     localPeer
     (TraceSendRecv (LocalTxMonitor (GenTxId blk) (GenTx blk) SlotNo)))
docTTxMonitor :: Documented
        (BlockFetch.TraceLabelPeer
           peer
           (TraceSendRecv
              (LTM.LocalTxMonitor
                 (GenTxId blk) (GenTx blk) SlotNo))))

    Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
txSubmissionTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer
      (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
    -> [Text])
-> (TraceLabelPeer
      peer
      (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer
      (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer
           (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"TxSubmission", Text
"Local"]
                TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
-> [Text]
namesForTTxSubmission
                TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
-> SeverityS
severityTTxSubmission
                TraceLabelPeer
  peer
  (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer
         (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
forall localPeer blk.
Documented
  (TraceLabelPeer
     localPeer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
docTTxSubmission [Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
txSubmissionTr]
    [([Text], DocuResult)]
txSubmissionTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer
        (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
txSubmissionTr
      (Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
forall localPeer blk.
Documented
  (TraceLabelPeer
     localPeer
     (TraceSendRecv (LocalTxSubmission (GenTx blk) (ApplyTxErr blk))))
docTTxSubmission :: Documented
         (BlockFetch.TraceLabelPeer
            peer
            (TraceSendRecv
               (LTS.LocalTxSubmission
                  (GenTx blk) (ApplyTxErr blk)))))


    Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
stateQueryTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))
    -> [Text])
-> (TraceLabelPeer
      peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer
           (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
               [Text
"StateQueryServer"]
                TraceLabelPeer
  peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))
-> [Text]
forall peer blk (query :: * -> *).
TraceLabelPeer
  peer (TraceSendRecv (LocalStateQuery blk (Point blk) query))
-> [Text]
namesForTStateQuery
                TraceLabelPeer
  peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))
-> SeverityS
forall peer blk (query :: * -> *).
TraceLabelPeer
  peer (TraceSendRecv (LocalStateQuery blk (Point blk) query))
-> SeverityS
severityTStateQuery
                TraceLabelPeer
  peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer
         (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
forall peer blk pt.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk pt (Query blk))))
docTStateQuery [Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
stateQueryTr]
    [([Text], DocuResult)]
stateQueryTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
-> Documented
     (TraceLabelPeer
        peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
stateQueryTr
      (Documented
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk (Point blk) (Query blk))))
forall peer blk pt.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (LocalStateQuery blk pt (Query blk))))
docTStateQuery :: Documented
            (BlockFetch.TraceLabelPeer peer
             (TraceSendRecv
               (LocalStateQuery blk (Point blk) (Query blk)))))

-- Node to Node

    Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
chainSyncNodeTr <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
    -> [Text])
-> (TraceLabelPeer
      peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer
           (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"ChainSync", Text
"Remote"]
                TraceLabelPeer
  peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
-> [Text]
namesForTChainSyncNode
                TraceLabelPeer
  peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
-> SeverityS
severityTChainSyncNode
                TraceLabelPeer
  peer (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer
         (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
forall peer x blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
docTChainSyncNodeToNode [Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
chainSyncNodeTr]
    [([Text], DocuResult)]
chainSyncNodeTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer
        (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv (ChainSync (Header blk) (Point blk) (Tip blk))))
chainSyncNodeTr
      (forall x.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
forall peer x blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
docTChainSyncNodeToNode :: Documented (BlockFetch.TraceLabelPeer peer (TraceSendRecv
          (ChainSync x (Point blk) (Tip blk)))))

    Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv
        (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
chainSyncSerialisedTr <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer
      (TraceSendRecv
         (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
    -> [Text])
-> (TraceLabelPeer
      peer
      (TraceSendRecv
         (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer
      (TraceSendRecv
         (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer
           (TraceSendRecv
              (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                 [Text
"ChainSync", Text
"Remote", Text
"Serialised"]
                TraceLabelPeer
  peer
  (TraceSendRecv
     (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv
     (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
-> [Text]
namesForTChainSyncSerialised
                TraceLabelPeer
  peer
  (TraceSendRecv
     (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer
  (TraceSendRecv
     (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
-> SeverityS
severityTChainSyncSerialised
                TraceLabelPeer
  peer
  (TraceSendRecv
     (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv
           (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer
         (TraceSendRecv
            (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer
     (TraceSendRecv
        (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
forall peer x blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
docTChainSyncNodeToNodeSerisalised [Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv
        (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
chainSyncSerialisedTr]
    [([Text], DocuResult)]
chainSyncSerialisedTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer
        (TraceSendRecv
           (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
-> Documented
     (TraceLabelPeer
        peer
        (TraceSendRecv
           (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer
     (TraceSendRecv
        (ChainSync (SerialisedHeader blk) (Point blk) (Tip blk))))
chainSyncSerialisedTr
      (forall x.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
forall peer x blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (ChainSync x (Point blk) (Tip blk))))
docTChainSyncNodeToNodeSerisalised :: Documented (BlockFetch.TraceLabelPeer peer (TraceSendRecv
          (ChainSync x (Point blk) (Tip blk)))))

    Trace
  IO
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
blockFetchTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer (TraceSendRecv (BlockFetch blk (Point blk)))
    -> [Text])
-> (TraceLabelPeer
      peer (TraceSendRecv (BlockFetch blk (Point blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer (TraceSendRecv (BlockFetch blk (Point blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"BlockFetch", Text
"Remote"]
                TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk)))
-> [Text]
forall peer blk.
TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk)))
-> [Text]
namesForTBlockFetch
                TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk)))
-> SeverityS
forall peer blk.
TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk)))
-> SeverityS
severityTBlockFetch
                TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
-> [Trace
      IO
      (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
forall peer x blk.
Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch x (Point blk))))
docTBlockFetch [Trace
  IO
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
blockFetchTr]
    [([Text], DocuResult)]
blockFetchTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
-> Documented
     (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch blk (Point blk))))
blockFetchTr
      (forall x.
Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch x (Point blk))))
forall peer x blk.
Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch x (Point blk))))
docTBlockFetch :: Documented
            (BlockFetch.TraceLabelPeer peer
             (TraceSendRecv
               (BlockFetch x (Point blk)))))

    Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
blockFetchSerialisedTr <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
    -> [Text])
-> (TraceLabelPeer
      peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"BlockFetch", Text
"Remote", Text
"Serialised"]
                TraceLabelPeer
  peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
-> [Text]
forall peer blk.
TraceLabelPeer
  peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
-> [Text]
namesForTBlockFetchSerialised
                TraceLabelPeer
  peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
-> SeverityS
forall peer blk.
TraceLabelPeer
  peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
-> SeverityS
severityTBlockFetchSerialised
                TraceLabelPeer
  peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
forall peer x blk.
Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch x (Point blk))))
docTBlockFetch [Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
blockFetchSerialisedTr]
    [([Text], DocuResult)]
blockFetchSerialisedTrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
-> Documented
     (TraceLabelPeer
        peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (BlockFetch (Serialised blk) (Point blk))))
blockFetchSerialisedTr
      (forall x.
Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch x (Point blk))))
forall peer x blk.
Documented
  (TraceLabelPeer peer (TraceSendRecv (BlockFetch x (Point blk))))
docTBlockFetch :: Documented
            (BlockFetch.TraceLabelPeer peer
             (TraceSendRecv
               (BlockFetch x (Point blk)))))

    Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
txSubmission2Tr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLabelPeer
      peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
    -> [Text])
-> (TraceLabelPeer
      peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
    -> SeverityS)
-> (TraceLabelPeer
      peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
    -> Privacy)
-> IO
     (Trace
        IO
        (TraceLabelPeer
           peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"TxSubmission", Text
"Remote"]
                TraceLabelPeer
  peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
-> [Text]
forall blk peer.
TraceLabelPeer
  peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
-> [Text]
namesForTxSubmission2Node
                TraceLabelPeer
  peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
-> SeverityS
forall blk peer.
TraceLabelPeer
  peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
-> SeverityS
severityTxSubmission2Node
                TraceLabelPeer
  peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk)))
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (TraceLabelPeer
        peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
-> [Trace
      IO
      (TraceLabelPeer
         peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
forall peer blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
docTTxSubmission2Node [Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
txSubmission2Tr]
    [([Text], DocuResult)]
txSubmission2TrDoc <- TraceConfig
-> Trace
     IO
     (TraceLabelPeer
        peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
-> Documented
     (TraceLabelPeer
        peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
txSubmission2Tr
      (Documented
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
forall peer blk.
Documented
  (TraceLabelPeer
     peer (TraceSendRecv (TxSubmission2 (GenTxId blk) (GenTx blk))))
docTTxSubmission2Node :: Documented
        (BlockFetch.TraceLabelPeer peer
          (TraceSendRecv
            (TxSubmission2 (GenTxId blk) (GenTx blk)))))

-- Diffusion
    Trace IO (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
dtMuxTr   <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace -> [Text])
-> (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace
    -> SeverityS)
-> (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace -> Privacy)
-> IO
     (Trace IO (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Mux", Text
"Remote"]
                WithMuxBearer (ConnectionId RemoteAddress) MuxTrace -> [Text]
forall peer. WithMuxBearer peer MuxTrace -> [Text]
namesForMux
                WithMuxBearer (ConnectionId RemoteAddress) MuxTrace -> SeverityS
forall peer. WithMuxBearer peer MuxTrace -> SeverityS
severityMux
                WithMuxBearer (ConnectionId RemoteAddress) MuxTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
-> [Trace IO (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
docMuxRemote [Trace IO (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
dtMuxTr]
    [([Text], DocuResult)]
dtMuxTrDoc <- TraceConfig
-> Trace IO (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
-> Documented (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
dtMuxTr
      (Documented (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace)
docMuxRemote :: Documented (WithMuxBearer (ConnectionId RemoteAddress) MuxTrace))

    Trace IO (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
dtLocalMuxTr   <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithMuxBearer (ConnectionId LocalAddress) MuxTrace -> [Text])
-> (WithMuxBearer (ConnectionId LocalAddress) MuxTrace
    -> SeverityS)
-> (WithMuxBearer (ConnectionId LocalAddress) MuxTrace -> Privacy)
-> IO
     (Trace IO (WithMuxBearer (ConnectionId LocalAddress) MuxTrace))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Mux", Text
"Local"]
                WithMuxBearer (ConnectionId LocalAddress) MuxTrace -> [Text]
forall peer. WithMuxBearer peer MuxTrace -> [Text]
namesForMux
                WithMuxBearer (ConnectionId LocalAddress) MuxTrace -> SeverityS
forall peer. WithMuxBearer peer MuxTrace -> SeverityS
severityMux
                WithMuxBearer (ConnectionId LocalAddress) MuxTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
-> [Trace IO (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
docMuxLocal [Trace IO (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
dtLocalMuxTr]
    [([Text], DocuResult)]
dtLocalMuxTrDoc <- TraceConfig
-> Trace IO (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
-> Documented (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
dtLocalMuxTr
      (Documented (WithMuxBearer (ConnectionId LocalAddress) MuxTrace)
docMuxLocal :: Documented (WithMuxBearer (ConnectionId LocalAddress) MuxTrace))

    Trace IO (HandshakeTr RemoteAddress NodeToNodeVersion)
dtHandshakeTr   <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (HandshakeTr RemoteAddress NodeToNodeVersion -> [Text])
-> (HandshakeTr RemoteAddress NodeToNodeVersion -> SeverityS)
-> (HandshakeTr RemoteAddress NodeToNodeVersion -> Privacy)
-> IO (Trace IO (HandshakeTr RemoteAddress NodeToNodeVersion))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Handshake", Text
"Remote"]
                HandshakeTr RemoteAddress NodeToNodeVersion -> [Text]
forall adr ver. HandshakeTr adr ver -> [Text]
namesForHandshake
                HandshakeTr RemoteAddress NodeToNodeVersion -> SeverityS
forall adr ver. HandshakeTr adr ver -> SeverityS
severityHandshake
                HandshakeTr RemoteAddress NodeToNodeVersion -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (HandshakeTr RemoteAddress NodeToNodeVersion)
-> [Trace IO (HandshakeTr RemoteAddress NodeToNodeVersion)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (HandshakeTr RemoteAddress NodeToNodeVersion)
forall ver. Documented (HandshakeTr RemoteAddress ver)
docHandshake [Trace IO (HandshakeTr RemoteAddress NodeToNodeVersion)
dtHandshakeTr]
    [([Text], DocuResult)]
dtHandshakeTrDoc <- TraceConfig
-> Trace IO (HandshakeTr RemoteAddress NodeToNodeVersion)
-> Documented (HandshakeTr RemoteAddress NodeToNodeVersion)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (HandshakeTr RemoteAddress NodeToNodeVersion)
dtHandshakeTr
      (Documented (HandshakeTr RemoteAddress NodeToNodeVersion)
forall ver. Documented (HandshakeTr RemoteAddress ver)
docHandshake ::
        Documented (NtN.HandshakeTr NtN.RemoteAddress NtN.NodeToNodeVersion))

    Trace IO (HandshakeTr LocalAddress NodeToClientVersion)
dtLocalHandshakeTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (HandshakeTr LocalAddress NodeToClientVersion -> [Text])
-> (HandshakeTr LocalAddress NodeToClientVersion -> SeverityS)
-> (HandshakeTr LocalAddress NodeToClientVersion -> Privacy)
-> IO (Trace IO (HandshakeTr LocalAddress NodeToClientVersion))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                 [Text
"Net", Text
"Handshake", Text
"Local"]
                HandshakeTr LocalAddress NodeToClientVersion -> [Text]
forall adr ver. HandshakeTr adr ver -> [Text]
namesForLocalHandshake
                HandshakeTr LocalAddress NodeToClientVersion -> SeverityS
forall adr ver. HandshakeTr adr ver -> SeverityS
severityLocalHandshake
                HandshakeTr LocalAddress NodeToClientVersion -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (HandshakeTr LocalAddress NodeToClientVersion)
-> [Trace IO (HandshakeTr LocalAddress NodeToClientVersion)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (HandshakeTr LocalAddress NodeToClientVersion)
forall ver. Documented (HandshakeTr LocalAddress ver)
docLocalHandshake [Trace IO (HandshakeTr LocalAddress NodeToClientVersion)
dtLocalHandshakeTr]
    [([Text], DocuResult)]
dtLocalHandshakeTrDoc <- TraceConfig
-> Trace IO (HandshakeTr LocalAddress NodeToClientVersion)
-> Documented (HandshakeTr LocalAddress NodeToClientVersion)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (HandshakeTr LocalAddress NodeToClientVersion)
dtLocalHandshakeTr
      (Documented (HandshakeTr LocalAddress NodeToClientVersion)
forall ver. Documented (HandshakeTr LocalAddress ver)
docLocalHandshake ::
        Documented (NtC.HandshakeTr LocalAddress NtC.NodeToClientVersion))

    Trace IO (InitializationTracer RemoteAddress LocalAddress)
dtDiffusionInitializationTr   <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (InitializationTracer RemoteAddress LocalAddress -> [Text])
-> (InitializationTracer RemoteAddress LocalAddress -> SeverityS)
-> (InitializationTracer RemoteAddress LocalAddress -> Privacy)
-> IO (Trace IO (InitializationTracer RemoteAddress LocalAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Startup", Text
"DiffusionInit"]
                InitializationTracer RemoteAddress LocalAddress -> [Text]
forall rard ladr. InitializationTracer rard ladr -> [Text]
namesForDiffusionInit
                InitializationTracer RemoteAddress LocalAddress -> SeverityS
forall rard ladr. InitializationTracer rard ladr -> SeverityS
severityDiffusionInit
                InitializationTracer RemoteAddress LocalAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (InitializationTracer RemoteAddress LocalAddress)
-> [Trace IO (InitializationTracer RemoteAddress LocalAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (InitializationTracer RemoteAddress LocalAddress)
docDiffusionInit [Trace IO (InitializationTracer RemoteAddress LocalAddress)
dtDiffusionInitializationTr]
    [([Text], DocuResult)]
dtDiffusionInitializationTrDoc <- TraceConfig
-> Trace IO (InitializationTracer RemoteAddress LocalAddress)
-> Documented (InitializationTracer RemoteAddress LocalAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (InitializationTracer RemoteAddress LocalAddress)
dtDiffusionInitializationTr
      (Documented (InitializationTracer RemoteAddress LocalAddress)
docDiffusionInit ::
        Documented (Diffusion.InitializationTracer Socket.SockAddr LocalAddress))

    Trace IO TraceLedgerPeers
dtLedgerPeersTr  <- Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLedgerPeers -> [Text])
-> (TraceLedgerPeers -> SeverityS)
-> (TraceLedgerPeers -> Privacy)
-> IO (Trace IO TraceLedgerPeers)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Peers", Text
"Ledger"]
                TraceLedgerPeers -> [Text]
namesForLedgerPeers
                TraceLedgerPeers -> SeverityS
severityLedgerPeers
                TraceLedgerPeers -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented TraceLedgerPeers
-> [Trace IO TraceLedgerPeers]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented TraceLedgerPeers
docLedgerPeers [Trace IO TraceLedgerPeers
dtLedgerPeersTr]
    [([Text], DocuResult)]
dtLedgerPeersTrDoc <- TraceConfig
-> Trace IO TraceLedgerPeers
-> Documented TraceLedgerPeers
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO TraceLedgerPeers
dtLedgerPeersTr
      (Documented TraceLedgerPeers
docLedgerPeers :: Documented TraceLedgerPeers)

-- DiffusionTracersExtra P2P

    Trace IO (TraceLocalRootPeers RemoteAddress SomeException)
localRootPeersTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TraceLocalRootPeers RemoteAddress SomeException -> [Text])
-> (TraceLocalRootPeers RemoteAddress SomeException -> SeverityS)
-> (TraceLocalRootPeers RemoteAddress SomeException -> Privacy)
-> IO (Trace IO (TraceLocalRootPeers RemoteAddress SomeException))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"Peers", Text
"LocalRoot"]
      TraceLocalRootPeers RemoteAddress SomeException -> [Text]
forall ntnAddr resolverError.
TraceLocalRootPeers ntnAddr resolverError -> [Text]
namesForLocalRootPeers
      TraceLocalRootPeers RemoteAddress SomeException -> SeverityS
forall ntnAddr resolverError.
TraceLocalRootPeers ntnAddr resolverError -> SeverityS
severityLocalRootPeers
      TraceLocalRootPeers RemoteAddress SomeException -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TraceLocalRootPeers RemoteAddress SomeException)
-> [Trace IO (TraceLocalRootPeers RemoteAddress SomeException)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TraceLocalRootPeers RemoteAddress SomeException)
forall ntnAddr resolverError.
Documented (TraceLocalRootPeers ntnAddr resolverError)
docLocalRootPeers [Trace IO (TraceLocalRootPeers RemoteAddress SomeException)
localRootPeersTr]
    [([Text], DocuResult)]
localRootPeersTrDoc <- TraceConfig
-> Trace IO (TraceLocalRootPeers RemoteAddress SomeException)
-> Documented (TraceLocalRootPeers RemoteAddress SomeException)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TraceLocalRootPeers RemoteAddress SomeException)
localRootPeersTr
      (Documented (TraceLocalRootPeers RemoteAddress SomeException)
forall ntnAddr resolverError.
Documented (TraceLocalRootPeers ntnAddr resolverError)
docLocalRootPeers :: Documented (TraceLocalRootPeers RemoteAddress SomeException))

    Trace IO TracePublicRootPeers
publicRootPeersTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TracePublicRootPeers -> [Text])
-> (TracePublicRootPeers -> SeverityS)
-> (TracePublicRootPeers -> Privacy)
-> IO (Trace IO TracePublicRootPeers)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"Peers", Text
"PublicRoot"]
      TracePublicRootPeers -> [Text]
namesForPublicRootPeers
      TracePublicRootPeers -> SeverityS
severityPublicRootPeers
      TracePublicRootPeers -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented TracePublicRootPeers
-> [Trace IO TracePublicRootPeers]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented TracePublicRootPeers
docPublicRootPeers [Trace IO TracePublicRootPeers
publicRootPeersTr]
    [([Text], DocuResult)]
publicRootPeersTrDoc <- TraceConfig
-> Trace IO TracePublicRootPeers
-> Documented TracePublicRootPeers
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO TracePublicRootPeers
publicRootPeersTr
      (Documented TracePublicRootPeers
docPublicRootPeers :: Documented TracePublicRootPeers)

    Trace IO (TracePeerSelection RemoteAddress)
peerSelectionTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (TracePeerSelection RemoteAddress -> [Text])
-> (TracePeerSelection RemoteAddress -> SeverityS)
-> (TracePeerSelection RemoteAddress -> Privacy)
-> IO (Trace IO (TracePeerSelection RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"PeerSelection", Text
"Selection"]
      TracePeerSelection RemoteAddress -> [Text]
forall peeraddr. TracePeerSelection peeraddr -> [Text]
namesForPeerSelection
      TracePeerSelection RemoteAddress -> SeverityS
forall peeraddr. TracePeerSelection peeraddr -> SeverityS
severityPeerSelection
      TracePeerSelection RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (TracePeerSelection RemoteAddress)
-> [Trace IO (TracePeerSelection RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (TracePeerSelection RemoteAddress)
docPeerSelection [Trace IO (TracePeerSelection RemoteAddress)
peerSelectionTr]
    [([Text], DocuResult)]
peerSelectionTrDoc <- TraceConfig
-> Trace IO (TracePeerSelection RemoteAddress)
-> Documented (TracePeerSelection RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (TracePeerSelection RemoteAddress)
peerSelectionTr
      (Documented (TracePeerSelection RemoteAddress)
docPeerSelection :: Documented (TracePeerSelection Socket.SockAddr))

    Trace IO (DebugPeerSelection RemoteAddress)
debugPeerSelectionTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (DebugPeerSelection RemoteAddress -> [Text])
-> (DebugPeerSelection RemoteAddress -> SeverityS)
-> (DebugPeerSelection RemoteAddress -> Privacy)
-> IO (Trace IO (DebugPeerSelection RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"PeerSelection", Text
"Initiator"]
      DebugPeerSelection RemoteAddress -> [Text]
namesForDebugPeerSelection
      DebugPeerSelection RemoteAddress -> SeverityS
severityDebugPeerSelection
      DebugPeerSelection RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (DebugPeerSelection RemoteAddress)
-> [Trace IO (DebugPeerSelection RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (DebugPeerSelection RemoteAddress)
docDebugPeerSelection [Trace IO (DebugPeerSelection RemoteAddress)
debugPeerSelectionTr]
    [([Text], DocuResult)]
debugPeerSelectionTrDoc <- TraceConfig
-> Trace IO (DebugPeerSelection RemoteAddress)
-> Documented (DebugPeerSelection RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (DebugPeerSelection RemoteAddress)
debugPeerSelectionTr
      (Documented (DebugPeerSelection RemoteAddress)
docDebugPeerSelection :: Documented (DebugPeerSelection Socket.SockAddr))

    Trace IO (DebugPeerSelection RemoteAddress)
debugPeerSelectionResponderTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (DebugPeerSelection RemoteAddress -> [Text])
-> (DebugPeerSelection RemoteAddress -> SeverityS)
-> (DebugPeerSelection RemoteAddress -> Privacy)
-> IO (Trace IO (DebugPeerSelection RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"PeerSelection", Text
"Responder"]
      DebugPeerSelection RemoteAddress -> [Text]
namesForDebugPeerSelection
      DebugPeerSelection RemoteAddress -> SeverityS
severityDebugPeerSelection
      DebugPeerSelection RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (DebugPeerSelection RemoteAddress)
-> [Trace IO (DebugPeerSelection RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (DebugPeerSelection RemoteAddress)
docDebugPeerSelection [Trace IO (DebugPeerSelection RemoteAddress)
debugPeerSelectionResponderTr]
    [([Text], DocuResult)]
debugPeerSelectionResponderTrDoc <- TraceConfig
-> Trace IO (DebugPeerSelection RemoteAddress)
-> Documented (DebugPeerSelection RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (DebugPeerSelection RemoteAddress)
debugPeerSelectionResponderTr
      (Documented (DebugPeerSelection RemoteAddress)
docDebugPeerSelection :: Documented (DebugPeerSelection Socket.SockAddr))

    Trace IO PeerSelectionCounters
peerSelectionCountersTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (PeerSelectionCounters -> [Text])
-> (PeerSelectionCounters -> SeverityS)
-> (PeerSelectionCounters -> Privacy)
-> IO (Trace IO PeerSelectionCounters)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"PeerSelection", Text
"Counters"]
      PeerSelectionCounters -> [Text]
namesForPeerSelectionCounters
      PeerSelectionCounters -> SeverityS
severityPeerSelectionCounters
      PeerSelectionCounters -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented PeerSelectionCounters
-> [Trace IO PeerSelectionCounters]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented PeerSelectionCounters
docPeerSelectionCounters [Trace IO PeerSelectionCounters
peerSelectionCountersTr]
    [([Text], DocuResult)]
peerSelectionCountersTrDoc <- TraceConfig
-> Trace IO PeerSelectionCounters
-> Documented PeerSelectionCounters
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO PeerSelectionCounters
peerSelectionCountersTr
      (Documented PeerSelectionCounters
docPeerSelectionCounters :: Documented PeerSelectionCounters)

    Trace IO (PeerSelectionActionsTrace RemoteAddress)
peerSelectionActionsTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (PeerSelectionActionsTrace RemoteAddress -> [Text])
-> (PeerSelectionActionsTrace RemoteAddress -> SeverityS)
-> (PeerSelectionActionsTrace RemoteAddress -> Privacy)
-> IO (Trace IO (PeerSelectionActionsTrace RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"PeerSelection", Text
"Actions"]
      PeerSelectionActionsTrace RemoteAddress -> [Text]
forall ntnAddr. PeerSelectionActionsTrace ntnAddr -> [Text]
namesForPeerSelectionActions
      PeerSelectionActionsTrace RemoteAddress -> SeverityS
forall ntnAddr. PeerSelectionActionsTrace ntnAddr -> SeverityS
severityPeerSelectionActions
      PeerSelectionActionsTrace RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (PeerSelectionActionsTrace RemoteAddress)
-> [Trace IO (PeerSelectionActionsTrace RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (PeerSelectionActionsTrace RemoteAddress)
forall ntnAddr. Documented (PeerSelectionActionsTrace ntnAddr)
docPeerSelectionActions [Trace IO (PeerSelectionActionsTrace RemoteAddress)
peerSelectionActionsTr]
    [([Text], DocuResult)]
peerSelectionActionsTrDoc <- TraceConfig
-> Trace IO (PeerSelectionActionsTrace RemoteAddress)
-> Documented (PeerSelectionActionsTrace RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (PeerSelectionActionsTrace RemoteAddress)
peerSelectionActionsTr
      (Documented (PeerSelectionActionsTrace RemoteAddress)
forall ntnAddr. Documented (PeerSelectionActionsTrace ntnAddr)
docPeerSelectionActions ::
        Documented (PeerSelectionActionsTrace Socket.SockAddr))

    Trace
  IO
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
connectionManagerTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ConnectionManagerTrace
      RemoteAddress
      (ConnectionHandlerTrace
         UnversionedProtocol UnversionedProtocolData)
    -> [Text])
-> (ConnectionManagerTrace
      RemoteAddress
      (ConnectionHandlerTrace
         UnversionedProtocol UnversionedProtocolData)
    -> SeverityS)
-> (ConnectionManagerTrace
      RemoteAddress
      (ConnectionHandlerTrace
         UnversionedProtocol UnversionedProtocolData)
    -> Privacy)
-> IO
     (Trace
        IO
        (ConnectionManagerTrace
           RemoteAddress
           (ConnectionHandlerTrace
              UnversionedProtocol UnversionedProtocolData)))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"ConnectionManager", Text
"Remote"]
      ConnectionManagerTrace
  RemoteAddress
  (ConnectionHandlerTrace
     UnversionedProtocol UnversionedProtocolData)
-> [Text]
forall ntnAddr cht. ConnectionManagerTrace ntnAddr cht -> [Text]
namesForConnectionManager
      ConnectionManagerTrace
  RemoteAddress
  (ConnectionHandlerTrace
     UnversionedProtocol UnversionedProtocolData)
-> SeverityS
forall addr versionNumber agreedOptions.
ConnectionManagerTrace
  addr (ConnectionHandlerTrace versionNumber agreedOptions)
-> SeverityS
severityConnectionManager
      ConnectionManagerTrace
  RemoteAddress
  (ConnectionHandlerTrace
     UnversionedProtocol UnversionedProtocolData)
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (ConnectionManagerTrace
        RemoteAddress
        (ConnectionHandlerTrace
           UnversionedProtocol UnversionedProtocolData))
-> [Trace
      IO
      (ConnectionManagerTrace
         RemoteAddress
         (ConnectionHandlerTrace
            UnversionedProtocol UnversionedProtocolData))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
forall ntnAddr ntnVersion ntnVersionData.
Documented
  (ConnectionManagerTrace
     ntnAddr (ConnectionHandlerTrace ntnVersion ntnVersionData))
docConnectionManager [Trace
  IO
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
connectionManagerTr]
    [([Text], DocuResult)]
connectionManagerTrDoc <- TraceConfig
-> Trace
     IO
     (ConnectionManagerTrace
        RemoteAddress
        (ConnectionHandlerTrace
           UnversionedProtocol UnversionedProtocolData))
-> Documented
     (ConnectionManagerTrace
        RemoteAddress
        (ConnectionHandlerTrace
           UnversionedProtocol UnversionedProtocolData))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
connectionManagerTr
      (Documented
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
forall ntnAddr ntnVersion ntnVersionData.
Documented
  (ConnectionManagerTrace
     ntnAddr (ConnectionHandlerTrace ntnVersion ntnVersionData))
docConnectionManager :: Documented
        (ConnectionManagerTrace
          Socket.SockAddr
          (ConnectionHandlerTrace UnversionedProtocol UnversionedProtocolData)))

    Trace IO (AbstractTransitionTrace RemoteAddress)
connectionManagerTransitionsTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (AbstractTransitionTrace RemoteAddress -> [Text])
-> (AbstractTransitionTrace RemoteAddress -> SeverityS)
-> (AbstractTransitionTrace RemoteAddress -> Privacy)
-> IO (Trace IO (AbstractTransitionTrace RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"ConnectionManager", Text
"Remote", Text
"Transition"]
      (AbstractTransitionTrace RemoteAddress -> [Text]
forall peerAddr. AbstractTransitionTrace peerAddr -> [Text]
namesForConnectionManagerTransition @RemoteAddress)
      AbstractTransitionTrace RemoteAddress -> SeverityS
forall peerAddr. AbstractTransitionTrace peerAddr -> SeverityS
severityConnectionManagerTransition
      AbstractTransitionTrace RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (AbstractTransitionTrace RemoteAddress)
-> [Trace IO (AbstractTransitionTrace RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (AbstractTransitionTrace RemoteAddress)
forall peerAddr. Documented (AbstractTransitionTrace peerAddr)
docConnectionManagerTransition [Trace IO (AbstractTransitionTrace RemoteAddress)
connectionManagerTransitionsTr]
    [([Text], DocuResult)]
connectionManagerTransitionsTrDoc <- TraceConfig
-> Trace IO (AbstractTransitionTrace RemoteAddress)
-> Documented (AbstractTransitionTrace RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (AbstractTransitionTrace RemoteAddress)
connectionManagerTransitionsTr
      (Documented (AbstractTransitionTrace RemoteAddress)
forall peerAddr. Documented (AbstractTransitionTrace peerAddr)
docConnectionManagerTransition ::
        Documented (ConnectionManager.AbstractTransitionTrace Socket.SockAddr))


    Trace IO (ServerTrace RemoteAddress)
serverTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ServerTrace RemoteAddress -> [Text])
-> (ServerTrace RemoteAddress -> SeverityS)
-> (ServerTrace RemoteAddress -> Privacy)
-> IO (Trace IO (ServerTrace RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"Server", Text
"Remote"]
      ServerTrace RemoteAddress -> [Text]
forall ntnAddr. ServerTrace ntnAddr -> [Text]
namesForServer
      ServerTrace RemoteAddress -> SeverityS
forall ntnAddr. ServerTrace ntnAddr -> SeverityS
severityServer
      ServerTrace RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (ServerTrace RemoteAddress)
-> [Trace IO (ServerTrace RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (ServerTrace RemoteAddress)
forall ntnAddr. Documented (ServerTrace ntnAddr)
docServer [Trace IO (ServerTrace RemoteAddress)
serverTr]
    [([Text], DocuResult)]
serverTrDoc <- TraceConfig
-> Trace IO (ServerTrace RemoteAddress)
-> Documented (ServerTrace RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (ServerTrace RemoteAddress)
serverTr
      (Documented (ServerTrace RemoteAddress)
forall ntnAddr. Documented (ServerTrace ntnAddr)
docServer :: Documented (ServerTrace Socket.SockAddr))

    Trace IO (InboundGovernorTrace RemoteAddress)
inboundGovernorTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (InboundGovernorTrace RemoteAddress -> [Text])
-> (InboundGovernorTrace RemoteAddress -> SeverityS)
-> (InboundGovernorTrace RemoteAddress -> Privacy)
-> IO (Trace IO (InboundGovernorTrace RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
       [Text
"Net", Text
"InboundGovernor", Text
"Remote"]
      InboundGovernorTrace RemoteAddress -> [Text]
forall peerAddr. InboundGovernorTrace peerAddr -> [Text]
namesForInboundGovernor
      InboundGovernorTrace RemoteAddress -> SeverityS
forall peerAddr. InboundGovernorTrace peerAddr -> SeverityS
severityInboundGovernor
      InboundGovernorTrace RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (InboundGovernorTrace RemoteAddress)
-> [Trace IO (InboundGovernorTrace RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (InboundGovernorTrace RemoteAddress)
docInboundGovernorRemote [Trace IO (InboundGovernorTrace RemoteAddress)
inboundGovernorTr]
    [([Text], DocuResult)]
inboundGovernorTrDoc <- TraceConfig
-> Trace IO (InboundGovernorTrace RemoteAddress)
-> Documented (InboundGovernorTrace RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (InboundGovernorTrace RemoteAddress)
inboundGovernorTr
      (Documented (InboundGovernorTrace RemoteAddress)
docInboundGovernorRemote :: Documented (InboundGovernorTrace Socket.SockAddr))

    Trace IO (RemoteTransitionTrace RemoteAddress)
inboundGovernorTransitionsTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (RemoteTransitionTrace RemoteAddress -> [Text])
-> (RemoteTransitionTrace RemoteAddress -> SeverityS)
-> (RemoteTransitionTrace RemoteAddress -> Privacy)
-> IO (Trace IO (RemoteTransitionTrace RemoteAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"InboundGovernor", Text
"Remote", Text
"Transition"]
      RemoteTransitionTrace RemoteAddress -> [Text]
forall peerAddr. RemoteTransitionTrace peerAddr -> [Text]
namesForInboundGovernorTransition
      RemoteTransitionTrace RemoteAddress -> SeverityS
forall peerAddr. RemoteTransitionTrace peerAddr -> SeverityS
severityInboundGovernorTransition
      RemoteTransitionTrace RemoteAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (RemoteTransitionTrace RemoteAddress)
-> [Trace IO (RemoteTransitionTrace RemoteAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (RemoteTransitionTrace RemoteAddress)
forall peerAddr. Documented (RemoteTransitionTrace peerAddr)
docInboundGovernorTransition [Trace IO (RemoteTransitionTrace RemoteAddress)
inboundGovernorTransitionsTr]
    [([Text], DocuResult)]
inboundGovernorTransitionsTrDoc <- TraceConfig
-> Trace IO (RemoteTransitionTrace RemoteAddress)
-> Documented (RemoteTransitionTrace RemoteAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (RemoteTransitionTrace RemoteAddress)
inboundGovernorTransitionsTr
       (Documented (RemoteTransitionTrace RemoteAddress)
forall peerAddr. Documented (RemoteTransitionTrace peerAddr)
docInboundGovernorTransition ::
        Documented (InboundGovernor.RemoteTransitionTrace Socket.SockAddr))


    Trace
  IO
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
localConnectionManagerTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ConnectionManagerTrace
      RemoteAddress
      (ConnectionHandlerTrace
         UnversionedProtocol UnversionedProtocolData)
    -> [Text])
-> (ConnectionManagerTrace
      RemoteAddress
      (ConnectionHandlerTrace
         UnversionedProtocol UnversionedProtocolData)
    -> SeverityS)
-> (ConnectionManagerTrace
      RemoteAddress
      (ConnectionHandlerTrace
         UnversionedProtocol UnversionedProtocolData)
    -> Privacy)
-> IO
     (Trace
        IO
        (ConnectionManagerTrace
           RemoteAddress
           (ConnectionHandlerTrace
              UnversionedProtocol UnversionedProtocolData)))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
       [Text
"Net", Text
"ConnectionManager", Text
"Local"]
      ConnectionManagerTrace
  RemoteAddress
  (ConnectionHandlerTrace
     UnversionedProtocol UnversionedProtocolData)
-> [Text]
forall ntnAddr cht. ConnectionManagerTrace ntnAddr cht -> [Text]
namesForConnectionManager
      ConnectionManagerTrace
  RemoteAddress
  (ConnectionHandlerTrace
     UnversionedProtocol UnversionedProtocolData)
-> SeverityS
forall addr versionNumber agreedOptions.
ConnectionManagerTrace
  addr (ConnectionHandlerTrace versionNumber agreedOptions)
-> SeverityS
severityConnectionManager
      ConnectionManagerTrace
  RemoteAddress
  (ConnectionHandlerTrace
     UnversionedProtocol UnversionedProtocolData)
-> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented
     (ConnectionManagerTrace
        RemoteAddress
        (ConnectionHandlerTrace
           UnversionedProtocol UnversionedProtocolData))
-> [Trace
      IO
      (ConnectionManagerTrace
         RemoteAddress
         (ConnectionHandlerTrace
            UnversionedProtocol UnversionedProtocolData))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
forall ntnAddr ntnVersion ntnVersionData.
Documented
  (ConnectionManagerTrace
     ntnAddr (ConnectionHandlerTrace ntnVersion ntnVersionData))
docConnectionManager [Trace
  IO
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
localConnectionManagerTr]
    [([Text], DocuResult)]
localConnectionManagerTrDoc <- TraceConfig
-> Trace
     IO
     (ConnectionManagerTrace
        RemoteAddress
        (ConnectionHandlerTrace
           UnversionedProtocol UnversionedProtocolData))
-> Documented
     (ConnectionManagerTrace
        RemoteAddress
        (ConnectionHandlerTrace
           UnversionedProtocol UnversionedProtocolData))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace
  IO
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
localConnectionManagerTr
      (Documented
  (ConnectionManagerTrace
     RemoteAddress
     (ConnectionHandlerTrace
        UnversionedProtocol UnversionedProtocolData))
forall ntnAddr ntnVersion ntnVersionData.
Documented
  (ConnectionManagerTrace
     ntnAddr (ConnectionHandlerTrace ntnVersion ntnVersionData))
docConnectionManager :: Documented
        (ConnectionManagerTrace
          Socket.SockAddr
          (ConnectionHandlerTrace
            UnversionedProtocol
            UnversionedProtocolData)))

    Trace IO (ServerTrace LocalAddress)
localServerTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (ServerTrace LocalAddress -> [Text])
-> (ServerTrace LocalAddress -> SeverityS)
-> (ServerTrace LocalAddress -> Privacy)
-> IO (Trace IO (ServerTrace LocalAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
      [Text
"Net", Text
"Server", Text
"Local"]
      ServerTrace LocalAddress -> [Text]
forall ntnAddr. ServerTrace ntnAddr -> [Text]
namesForServer
      ServerTrace LocalAddress -> SeverityS
forall ntnAddr. ServerTrace ntnAddr -> SeverityS
severityServer
      ServerTrace LocalAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (ServerTrace LocalAddress)
-> [Trace IO (ServerTrace LocalAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (ServerTrace LocalAddress)
forall ntnAddr. Documented (ServerTrace ntnAddr)
docServer [Trace IO (ServerTrace LocalAddress)
localServerTr]
    [([Text], DocuResult)]
localServerTrDoc <- TraceConfig
-> Trace IO (ServerTrace LocalAddress)
-> Documented (ServerTrace LocalAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (ServerTrace LocalAddress)
localServerTr
      (Documented (ServerTrace LocalAddress)
forall ntnAddr. Documented (ServerTrace ntnAddr)
docServer :: Documented (ServerTrace LocalAddress))


    Trace IO (InboundGovernorTrace LocalAddress)
localInboundGovernorTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (InboundGovernorTrace LocalAddress -> [Text])
-> (InboundGovernorTrace LocalAddress -> SeverityS)
-> (InboundGovernorTrace LocalAddress -> Privacy)
-> IO (Trace IO (InboundGovernorTrace LocalAddress))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
      Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
       [Text
"Net", Text
"InboundGovernor", Text
"Local"]
      InboundGovernorTrace LocalAddress -> [Text]
forall peerAddr. InboundGovernorTrace peerAddr -> [Text]
namesForInboundGovernor
      InboundGovernorTrace LocalAddress -> SeverityS
forall peerAddr. InboundGovernorTrace peerAddr -> SeverityS
severityInboundGovernor
      InboundGovernorTrace LocalAddress -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (InboundGovernorTrace LocalAddress)
-> [Trace IO (InboundGovernorTrace LocalAddress)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (InboundGovernorTrace LocalAddress)
docInboundGovernorLocal [Trace IO (InboundGovernorTrace LocalAddress)
localInboundGovernorTr]
    [([Text], DocuResult)]
localInboundGovernorTrDoc <- TraceConfig
-> Trace IO (InboundGovernorTrace LocalAddress)
-> Documented (InboundGovernorTrace LocalAddress)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (InboundGovernorTrace LocalAddress)
localInboundGovernorTr
      (Documented (InboundGovernorTrace LocalAddress)
docInboundGovernorLocal :: Documented (InboundGovernorTrace LocalAddress))

-- DiffusionTracersExtra nonP2P

    Trace IO (WithIPList (SubscriptionTrace RemoteAddress))
dtIpSubscriptionTr   <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithIPList (SubscriptionTrace RemoteAddress) -> [Text])
-> (WithIPList (SubscriptionTrace RemoteAddress) -> SeverityS)
-> (WithIPList (SubscriptionTrace RemoteAddress) -> Privacy)
-> IO (Trace IO (WithIPList (SubscriptionTrace RemoteAddress)))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Subscription", Text
"IP"]
                WithIPList (SubscriptionTrace RemoteAddress) -> [Text]
namesForIPSubscription
                WithIPList (SubscriptionTrace RemoteAddress) -> SeverityS
severityIPSubscription
                WithIPList (SubscriptionTrace RemoteAddress) -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithIPList (SubscriptionTrace RemoteAddress))
-> [Trace IO (WithIPList (SubscriptionTrace RemoteAddress))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithIPList (SubscriptionTrace RemoteAddress))
docIPSubscription [Trace IO (WithIPList (SubscriptionTrace RemoteAddress))
dtIpSubscriptionTr]
    [([Text], DocuResult)]
dtIpSubscriptionTrDoc <- TraceConfig
-> Trace IO (WithIPList (SubscriptionTrace RemoteAddress))
-> Documented (WithIPList (SubscriptionTrace RemoteAddress))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithIPList (SubscriptionTrace RemoteAddress))
dtIpSubscriptionTr
      (Documented (WithIPList (SubscriptionTrace RemoteAddress))
docIPSubscription ::
        Documented (WithIPList (SubscriptionTrace Socket.SockAddr)))

    Trace IO (WithDomainName (SubscriptionTrace RemoteAddress))
dtDnsSubscriptionTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithDomainName (SubscriptionTrace RemoteAddress) -> [Text])
-> (WithDomainName (SubscriptionTrace RemoteAddress) -> SeverityS)
-> (WithDomainName (SubscriptionTrace RemoteAddress) -> Privacy)
-> IO (Trace IO (WithDomainName (SubscriptionTrace RemoteAddress)))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"Subscription", Text
"DNS"]
                WithDomainName (SubscriptionTrace RemoteAddress) -> [Text]
namesForDNSSubscription
                WithDomainName (SubscriptionTrace RemoteAddress) -> SeverityS
severityDNSSubscription
                WithDomainName (SubscriptionTrace RemoteAddress) -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithDomainName (SubscriptionTrace RemoteAddress))
-> [Trace IO (WithDomainName (SubscriptionTrace RemoteAddress))]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithDomainName (SubscriptionTrace RemoteAddress))
docDNSSubscription [Trace IO (WithDomainName (SubscriptionTrace RemoteAddress))
dtDnsSubscriptionTr]
    [([Text], DocuResult)]
dtDnsSubscriptionTrDoc <- TraceConfig
-> Trace IO (WithDomainName (SubscriptionTrace RemoteAddress))
-> Documented (WithDomainName (SubscriptionTrace RemoteAddress))
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithDomainName (SubscriptionTrace RemoteAddress))
dtDnsSubscriptionTr
      (Documented (WithDomainName (SubscriptionTrace RemoteAddress))
docDNSSubscription ::
        Documented (WithDomainName (SubscriptionTrace Socket.SockAddr)))

    Trace IO (WithDomainName DnsTrace)
dtDnsResolverTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithDomainName DnsTrace -> [Text])
-> (WithDomainName DnsTrace -> SeverityS)
-> (WithDomainName DnsTrace -> Privacy)
-> IO (Trace IO (WithDomainName DnsTrace))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"DNSResolver"]
                WithDomainName DnsTrace -> [Text]
namesForDNSResolver
                WithDomainName DnsTrace -> SeverityS
severityDNSResolver
                WithDomainName DnsTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithDomainName DnsTrace)
-> [Trace IO (WithDomainName DnsTrace)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithDomainName DnsTrace)
docDNSResolver [Trace IO (WithDomainName DnsTrace)
dtDnsResolverTr]
    [([Text], DocuResult)]
dtDnsResolverTrDoc <- TraceConfig
-> Trace IO (WithDomainName DnsTrace)
-> Documented (WithDomainName DnsTrace)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithDomainName DnsTrace)
dtDnsResolverTr
      (Documented (WithDomainName DnsTrace)
docDNSResolver :: Documented (WithDomainName DnsTrace))

    Trace IO (WithAddr RemoteAddress ErrorPolicyTrace)
dtErrorPolicyTr  <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithAddr RemoteAddress ErrorPolicyTrace -> [Text])
-> (WithAddr RemoteAddress ErrorPolicyTrace -> SeverityS)
-> (WithAddr RemoteAddress ErrorPolicyTrace -> Privacy)
-> IO (Trace IO (WithAddr RemoteAddress ErrorPolicyTrace))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"ErrorPolicy", Text
"Remote"]
                WithAddr RemoteAddress ErrorPolicyTrace -> [Text]
namesForErrorPolicy
                WithAddr RemoteAddress ErrorPolicyTrace -> SeverityS
severityErrorPolicy
                WithAddr RemoteAddress ErrorPolicyTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithAddr RemoteAddress ErrorPolicyTrace)
-> [Trace IO (WithAddr RemoteAddress ErrorPolicyTrace)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithAddr RemoteAddress ErrorPolicyTrace)
docErrorPolicy [Trace IO (WithAddr RemoteAddress ErrorPolicyTrace)
dtErrorPolicyTr]
    [([Text], DocuResult)]
dtErrorPolicyTrDoc <- TraceConfig
-> Trace IO (WithAddr RemoteAddress ErrorPolicyTrace)
-> Documented (WithAddr RemoteAddress ErrorPolicyTrace)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithAddr RemoteAddress ErrorPolicyTrace)
dtErrorPolicyTr
      (Documented (WithAddr RemoteAddress ErrorPolicyTrace)
docErrorPolicy :: Documented (WithAddr Socket.SockAddr ErrorPolicyTrace))

    Trace IO (WithAddr LocalAddress ErrorPolicyTrace)
dtLocalErrorPolicyTr <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (WithAddr LocalAddress ErrorPolicyTrace -> [Text])
-> (WithAddr LocalAddress ErrorPolicyTrace -> SeverityS)
-> (WithAddr LocalAddress ErrorPolicyTrace -> Privacy)
-> IO (Trace IO (WithAddr LocalAddress ErrorPolicyTrace))
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"ErrorPolicy", Text
"Local"]
                WithAddr LocalAddress ErrorPolicyTrace -> [Text]
namesForLocalErrorPolicy
                WithAddr LocalAddress ErrorPolicyTrace -> SeverityS
severityLocalErrorPolicy
                WithAddr LocalAddress ErrorPolicyTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented (WithAddr LocalAddress ErrorPolicyTrace)
-> [Trace IO (WithAddr LocalAddress ErrorPolicyTrace)]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented (WithAddr LocalAddress ErrorPolicyTrace)
docLocalErrorPolicy [Trace IO (WithAddr LocalAddress ErrorPolicyTrace)
dtLocalErrorPolicyTr]
    [([Text], DocuResult)]
dtLocalErrorPolicyTrDoc <- TraceConfig
-> Trace IO (WithAddr LocalAddress ErrorPolicyTrace)
-> Documented (WithAddr LocalAddress ErrorPolicyTrace)
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO (WithAddr LocalAddress ErrorPolicyTrace)
dtLocalErrorPolicyTr
      (Documented (WithAddr LocalAddress ErrorPolicyTrace)
docLocalErrorPolicy :: Documented (WithAddr LocalAddress ErrorPolicyTrace))

    Trace IO AcceptConnectionsPolicyTrace
dtAcceptPolicyTr    <-  Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (AcceptConnectionsPolicyTrace -> [Text])
-> (AcceptConnectionsPolicyTrace -> SeverityS)
-> (AcceptConnectionsPolicyTrace -> Privacy)
-> IO (Trace IO AcceptConnectionsPolicyTrace)
forall evt.
LogFormatting evt =>
Trace IO FormattedMessage
-> Trace IO FormattedMessage
-> Maybe (Trace IO FormattedMessage)
-> [Text]
-> (evt -> [Text])
-> (evt -> SeverityS)
-> (evt -> Privacy)
-> IO (Trace IO evt)
mkCardanoTracer
                Trace IO FormattedMessage
trBase Trace IO FormattedMessage
trForward Maybe (Trace IO FormattedMessage)
mbTrEKG
                [Text
"Net", Text
"AcceptPolicy"]
                AcceptConnectionsPolicyTrace -> [Text]
namesForAcceptPolicy
                AcceptConnectionsPolicyTrace -> SeverityS
severityAcceptPolicy
                AcceptConnectionsPolicyTrace -> Privacy
forall a. a -> Privacy
allPublic
    TraceConfig
-> Documented AcceptConnectionsPolicyTrace
-> [Trace IO AcceptConnectionsPolicyTrace]
-> IO ()
forall a. TraceConfig -> Documented a -> [Trace IO a] -> IO ()
configureTracers TraceConfig
trConfig Documented AcceptConnectionsPolicyTrace
docAcceptPolicy [Trace IO AcceptConnectionsPolicyTrace
dtAcceptPolicyTr]
    [([Text], DocuResult)]
dtAcceptPolicyTrDoc <- TraceConfig
-> Trace IO AcceptConnectionsPolicyTrace
-> Documented AcceptConnectionsPolicyTrace
-> IO [([Text], DocuResult)]
forall a.
TraceConfig
-> Trace IO a -> Documented a -> IO [([Text], DocuResult)]
documentTracer TraceConfig
trConfig Trace IO AcceptConnectionsPolicyTrace
dtAcceptPolicyTr
      (Documented AcceptConnectionsPolicyTrace
docAcceptPolicy :: Documented NtN.AcceptConnectionsPolicyTrace)

    let bl :: [([Text], DocuResult)]
bl =  [([Text], DocuResult)]
nodeInfoTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
stateTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
nodeStartupInfoTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
resourcesTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
startupTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
shutdownTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
peersTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainDBTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
replayBlockTrDoc
-- Consensus
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainSyncClientTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainSyncServerHeaderTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainSyncServerBlockTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
blockFetchDecisionTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
blockFetchClientTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
clientMetricsDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
blockFetchServerTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
forgeKESInfoTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
txInboundTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
txOutboundTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
localTxSubmissionServerTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
mempoolTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
forgeTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
forgeThreadStatsTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
blockchainTimeTrDoc
-- NodeToClient
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
keepAliveClientTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainSyncTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
txMonitorTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
txSubmissionTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
stateQueryTrDoc
-- Node to Node
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainSyncNodeTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
chainSyncSerialisedTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
blockFetchTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
blockFetchSerialisedTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
txSubmission2TrDoc
-- Diffusion
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtMuxTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtLocalMuxTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtHandshakeTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtLocalHandshakeTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtDiffusionInitializationTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtLedgerPeersTrDoc
-- DiffusionTracersExtra P2P
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
localRootPeersTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
publicRootPeersTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
peerSelectionTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
debugPeerSelectionTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
debugPeerSelectionResponderTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
peerSelectionCountersTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
peerSelectionActionsTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
connectionManagerTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
connectionManagerTransitionsTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
serverTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
inboundGovernorTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
inboundGovernorTransitionsTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
localConnectionManagerTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
localServerTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
localInboundGovernorTrDoc
-- DiffusionTracersExtra nonP2P
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtIpSubscriptionTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtDnsSubscriptionTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtDnsResolverTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtErrorPolicyTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtLocalErrorPolicyTrDoc
            [([Text], DocuResult)]
-> [([Text], DocuResult)] -> [([Text], DocuResult)]
forall a. Semigroup a => a -> a -> a
<> [([Text], DocuResult)]
dtAcceptPolicyTrDoc

    Text
res <- [([Text], DocuResult)] -> TraceConfig -> IO Text
buildersToText [([Text], DocuResult)]
bl TraceConfig
trConfig
    FilePath -> Text -> IO ()
T.writeFile FilePath
outputFileName Text
res
    () -> IO ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()