metrics

package
v0.29.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 19, 2023 License: AGPL-3.0 Imports: 26 Imported by: 5

Documentation

Index

Constants

View Source 
const (
	HotstuffEventTypeTimeout    = "timeout"
	HotstuffEventTypeOnProposal = "onproposal"
	HotstuffEventTypeOnVote     = "onvote"
	HotstuffEventTypeOnQC       = "onqc"
)

HotStuff Metrics

View Source 
const (
	LabelChannel             = "topic"
	LabelChain               = "chain"
	LabelProposer            = "proposer"
	EngineLabel              = "engine"
	LabelResource            = "resource"
	LabelProtocol            = "protocol"
	LabelMessage             = "message"
	LabelNodeID              = "nodeid"
	LabelNodeAddress         = "nodeaddress"
	LabelNodeRole            = "noderole"
	LabelNodeInfo            = "nodeinfo"
	LabelNodeVersion         = "nodeversion"
	LabelPriority            = "priority"
	LabelComputationKind     = "computationKind"
	LabelConnectionDirection = "direction"
	LabelConnectionUseFD     = "usefd" // whether the connection is using a file descriptor
)
View Source 
const (
	// collection
	EngineClusterCompliance      = "proposal"
	EngineCollectionIngest       = "collection_ingest"
	EngineCollectionProvider     = "collection_provider"
	EngineClusterSynchronization = "cluster-sync"
	// consensus
	EnginePropagation        = "propagation"
	EngineCompliance         = "compliance"
	EngineConsensusProvider  = "consensus_provider"
	EngineConsensusIngestion = "consensus_ingestion"
	EngineSealing            = "sealing"
	EngineSynchronization    = "sync"
	// common
	EngineFollower = "follower"
)
View Source 
const (
	ResourceUndefined                    = "undefined"
	ResourceProposal                     = "proposal"
	ResourceHeader                       = "header"
	ResourceFinalizedHeight              = "finalized_height"
	ResourceIndex                        = "index"
	ResourceIdentity                     = "identity"
	ResourceGuarantee                    = "guarantee"
	ResourceResult                       = "result"
	ResourceResultApprovals              = "result_approvals"
	ResourceReceipt                      = "receipt"
	ResourceMyReceipt                    = "my_receipt"
	ResourceCollection                   = "collection"
	ResourceApproval                     = "approval"
	ResourceSeal                         = "seal"
	ResourcePendingIncorporatedSeal      = "pending_incorporated_seal"
	ResourceCommit                       = "commit"
	ResourceTransaction                  = "transaction"
	ResourceClusterPayload               = "cluster_payload"
	ResourceClusterProposal              = "cluster_proposal"
	ResourceProcessedResultID            = "processed_result_id"          // verification node, finder engine // TODO: remove finder engine labels
	ResourceDiscardedResultID            = "discarded_result_id"          // verification node, finder engine
	ResourcePendingReceipt               = "pending_receipt"              // verification node, finder engine
	ResourceReceiptIDsByResult           = "receipt_ids_by_result"        // verification node, finder engine
	ResourcePendingReceiptIDsByBlock     = "pending_receipt_ids_by_block" // verification node, finder engine
	ResourcePendingResult                = "pending_result"               // verification node, match engine
	ResourceChunkIDsByResult             = "chunk_ids_by_result"          // verification node, match engine
	ResourcePendingChunk                 = "pending_chunk"                // verification node, match engine
	ResourcePendingBlock                 = "pending_block"                // verification node, match engine
	ResourceCachedReceipt                = "cached_receipt"               // verification node, finder engine
	ResourceCachedBlockID                = "cached_block_id"              // verification node, finder engine
	ResourceChunkStatus                  = "chunk_status"                 // verification node, fetcher engine
	ResourceChunkRequest                 = "chunk_request"                // verification node, requester engine
	ResourceChunkConsumer                = "chunk_consumer_jobs"          // verification node
	ResourceBlockConsumer                = "block_consumer_jobs"          // verification node
	ResourceEpochSetup                   = "epoch_setup"
	ResourceEpochCommit                  = "epoch_commit"
	ResourceEpochStatus                  = "epoch_status"
	ResourceNetworkingReceiveCache       = "networking_received_message"        // networking layer
	ResourcePublicNetworkingReceiveCache = "public_networking_received_message" // networking layer
	ResourceNetworkingDnsIpCache         = "networking_dns_ip_cache"            // networking layer
	ResourceNetworkingDnsTxtCache        = "networking_dns_txt_cache"           // networking layer

	ResourceClusterBlockProposalQueue = "cluster_compliance_proposal_queue" // collection node, compliance engine
	ResourceClusterBlockVoteQueue     = "cluster_compliance_vote_queue"     // collection node, compliance engine
	ResourceTransactionIngestQueue    = "ingest_transaction_queue"          // collection node, ingest engine
	ResourceBeaconKey                 = "beacon-key"                        // consensus node, DKG engine
	ResourceApprovalQueue             = "sealing_approval_queue"            // consensus node, sealing engine
	ResourceReceiptQueue              = "sealing_receipt_queue"             // consensus node, sealing engine
	ResourceApprovalResponseQueue     = "sealing_approval_response_queue"   // consensus node, sealing engine
	ResourceBlockResponseQueue        = "compliance_block_response_queue"   // consensus node, compliance engine
	ResourceBlockProposalQueue        = "compliance_proposal_queue"         // consensus node, compliance engine
	ResourceBlockVoteQueue            = "compliance_vote_queue"             // consensus node, compliance engine
	ResourceCollectionGuaranteesQueue = "ingestion_col_guarantee_queue"     // consensus node, ingestion engine
	ResourceChunkDataPack             = "chunk_data_pack"                   // execution node
	ResourceChunkDataPackRequests     = "chunk_data_pack_request"           // execution node
	ResourceEvents                    = "events"                            // execution node
	ResourceServiceEvents             = "service_events"                    // execution node
	ResourceTransactionResults        = "transaction_results"               // execution node
	ResourceTransactionResultIndices  = "transaction_result_indices"        // execution node
	ResourceTransactionResultByBlock  = "transaction_result_by_block"       // execution node
)
View Source 
const (
	MessageCollectionGuarantee  = "guarantee"
	MessageBlockProposal        = "proposal"
	MessageBlockVote            = "vote"
	MessageExecutionReceipt     = "receipt"
	MessageResultApproval       = "approval"
	MessageSyncRequest          = "ping"
	MessageSyncResponse         = "pong"
	MessageRangeRequest         = "range"
	MessageBatchRequest         = "batch"
	MessageBlockResponse        = "block"
	MessageSyncedBlock          = "synced_block"
	MessageClusterBlockProposal = "cluster_proposal"
	MessageClusterBlockVote     = "cluster_vote"
	MessageClusterBlockResponse = "cluster_block_response"
	MessageSyncedClusterBlock   = "synced_cluster_block"
	MessageTransaction          = "transaction"
	MessageSubmitGuarantee      = "submit_guarantee"
	MessageCollectionRequest    = "collection_request"
	MessageCollectionResponse   = "collection_response"
	MessageEntityRequest        = "entity_request"
	MessageEntityResponse       = "entity_response"
)
View Source 
const (
	KiB = 1 << (10 * iota)
	MiB
	GiB
)
View Source 
const ExecutionDataRequestRetryable = "retryable"
View Source 
const LabelRateLimitReason = "reason"
View Source 
const LabelViolationReason = "reason"

Variables

This section is empty.

Functions

func NewExecutionDataRequesterCollector 

func NewExecutionDataRequesterCollector() module.ExecutionDataRequesterMetrics

func NewRateLimitedBlockstoreCollector 

func NewRateLimitedBlockstoreCollector(prefix string) module.RateLimitedBlockstoreMetrics

func RegisterBadgerMetrics 

func RegisterBadgerMetrics() error

Types

type AccessCollector 

type AccessCollector struct {
	// contains filtered or unexported fields
}

func NewAccessCollector 

func NewAccessCollector() *AccessCollector

func (*AccessCollector) ConnectionAddedToPool 

func (ac *AccessCollector) ConnectionAddedToPool()

func (*AccessCollector) ConnectionFromPoolEvicted 

func (ac *AccessCollector) ConnectionFromPoolEvicted()

func (*AccessCollector) ConnectionFromPoolInvalidated 

func (ac *AccessCollector) ConnectionFromPoolInvalidated()

func (*AccessCollector) ConnectionFromPoolReused 

func (ac *AccessCollector) ConnectionFromPoolReused()

func (*AccessCollector) ConnectionFromPoolUpdated 

func (ac *AccessCollector) ConnectionFromPoolUpdated()

func (*AccessCollector) NewConnectionEstablished 

func (ac *AccessCollector) NewConnectionEstablished()

func (*AccessCollector) TotalConnectionsInPool 

func (ac *AccessCollector) TotalConnectionsInPool(connectionCount uint, connectionPoolSize uint)

type BitswapCollector 

type BitswapCollector struct {
	// contains filtered or unexported fields
}

func NewBitswapCollector 

func NewBitswapCollector() *BitswapCollector

func (*BitswapCollector) BlobsReceived 

func (bc *BitswapCollector) BlobsReceived(prefix string, n uint64)

func (*BitswapCollector) BlobsSent 

func (bc *BitswapCollector) BlobsSent(prefix string, n uint64)

func (*BitswapCollector) DataReceived 

func (bc *BitswapCollector) DataReceived(prefix string, n uint64)

func (*BitswapCollector) DataSent 

func (bc *BitswapCollector) DataSent(prefix string, n uint64)

func (*BitswapCollector) DupBlobsReceived 

func (bc *BitswapCollector) DupBlobsReceived(prefix string, n uint64)

func (*BitswapCollector) DupDataReceived 

func (bc *BitswapCollector) DupDataReceived(prefix string, n uint64)

func (*BitswapCollector) MessagesReceived 

func (bc *BitswapCollector) MessagesReceived(prefix string, n uint64)

func (*BitswapCollector) Peers 

func (bc *BitswapCollector) Peers(prefix string, n int)

func (*BitswapCollector) Wantlist 

func (bc *BitswapCollector) Wantlist(prefix string, n int)

type CacheCollector 

type CacheCollector struct {
	// contains filtered or unexported fields
}

func NewCacheCollector 

func NewCacheCollector(chain flow.ChainID) *CacheCollector

func (*CacheCollector) CacheEntries 

func (cc *CacheCollector) CacheEntries(resource string, entries uint)

CacheEntries records the size of the node identities cache.

func (*CacheCollector) CacheHit 

func (cc *CacheCollector) CacheHit(resource string)

CacheHit records the number of hits in the node identities cache.

func (*CacheCollector) CacheMiss 

func (cc *CacheCollector) CacheMiss(resource string)

CacheMiss report the number of times the queried item is not found in the cache, but found in the database.

func (*CacheCollector) CacheNotFound 

func (cc *CacheCollector) CacheNotFound(resource string)

CacheNotFound records the number of times the queried item was not found in either cache or database.

type ChainSyncCollector 

type ChainSyncCollector struct {
	// contains filtered or unexported fields
}

func NewChainSyncCollector 

func NewChainSyncCollector() *ChainSyncCollector

func (*ChainSyncCollector) BatchRequested 

func (c *ChainSyncCollector) BatchRequested(batch chainsync.Batch)

func (*ChainSyncCollector) PrunedBlockByHeight 

func (c *ChainSyncCollector) PrunedBlockByHeight(status *chainsync.Status)

func (*ChainSyncCollector) PrunedBlockById 

func (c *ChainSyncCollector) PrunedBlockById(status *chainsync.Status)

func (*ChainSyncCollector) PrunedBlocks 

func (c *ChainSyncCollector) PrunedBlocks(totalByHeight, totalById, storedByHeight, storedById int)

func (*ChainSyncCollector) RangeRequested 

func (c *ChainSyncCollector) RangeRequested(ran chainsync.Range)

type CleanerCollector 

type CleanerCollector struct {
	// contains filtered or unexported fields
}

func NewCleanerCollector 

func NewCleanerCollector() *CleanerCollector

func (*CleanerCollector) RanGC 

func (cc *CleanerCollector) RanGC(duration time.Duration)

RanGC records a successful run of the Badger garbage collector.

type CollectionCollector 

type CollectionCollector struct {
	// contains filtered or unexported fields
}

func NewCollectionCollector 

func NewCollectionCollector(tracer module.Tracer) *CollectionCollector

func (*CollectionCollector) ClusterBlockFinalized 

func (cc *CollectionCollector) ClusterBlockFinalized(block *cluster.Block)

ClusterBlockFinalized updates the guaranteed collection size gauge and finishes the tx->collection span for each constituent transaction.

func (*CollectionCollector) ClusterBlockProposed 

func (cc *CollectionCollector) ClusterBlockProposed(block *cluster.Block)

ClusterBlockProposed tracks the size and number of proposals, as well as starting the collection->guarantee span.

func (*CollectionCollector) TransactionIngested 

func (cc *CollectionCollector) TransactionIngested(txID flow.Identifier)

TransactionIngested starts a span to trace the duration of a transaction from being created to being included as part of a collection.

type ComplianceCollector 

type ComplianceCollector struct {
	// contains filtered or unexported fields
}

func NewComplianceCollector 

func NewComplianceCollector() *ComplianceCollector

func (*ComplianceCollector) BlockFinalized 

func (cc *ComplianceCollector) BlockFinalized(block *flow.Block)

BlockFinalized reports metrics about finalized blocks.

func (*ComplianceCollector) BlockProposalDuration 

func (cc *ComplianceCollector) BlockProposalDuration(duration time.Duration)

func (*ComplianceCollector) BlockSealed 

func (cc *ComplianceCollector) BlockSealed(block *flow.Block)

BlockSealed reports metrics about sealed blocks.

func (*ComplianceCollector) CommittedEpochFinalView 

func (cc *ComplianceCollector) CommittedEpochFinalView(view uint64)

func (*ComplianceCollector) CurrentDKGPhase1FinalView 

func (cc *ComplianceCollector) CurrentDKGPhase1FinalView(view uint64)

func (*ComplianceCollector) CurrentDKGPhase2FinalView 

func (cc *ComplianceCollector) CurrentDKGPhase2FinalView(view uint64)

func (*ComplianceCollector) CurrentDKGPhase3FinalView 

func (cc *ComplianceCollector) CurrentDKGPhase3FinalView(view uint64)

func (*ComplianceCollector) CurrentEpochCounter 

func (cc *ComplianceCollector) CurrentEpochCounter(counter uint64)

func (*ComplianceCollector) CurrentEpochFinalView 

func (cc *ComplianceCollector) CurrentEpochFinalView(view uint64)

func (*ComplianceCollector) CurrentEpochPhase 

func (cc *ComplianceCollector) CurrentEpochPhase(phase flow.EpochPhase)

func (*ComplianceCollector) EpochEmergencyFallbackTriggered 

func (cc *ComplianceCollector) EpochEmergencyFallbackTriggered()

func (*ComplianceCollector) FinalizedHeight 

func (cc *ComplianceCollector) FinalizedHeight(height uint64)

FinalizedHeight sets the finalized height.

func (*ComplianceCollector) SealedHeight 

func (cc *ComplianceCollector) SealedHeight(height uint64)

SealedHeight sets the finalized height.

type ConsensusCollector 

type ConsensusCollector struct {
	// contains filtered or unexported fields
}

ConsensusCollector ...

func NewConsensusCollector 

func NewConsensusCollector(tracer module.Tracer, registerer prometheus.Registerer) *ConsensusCollector

NewConsensusCollector created a new consensus collector

func (*ConsensusCollector) CheckSealingDuration 

func (cc *ConsensusCollector) CheckSealingDuration(duration time.Duration)

CheckSealingDuration increases the number of seconds spent in checkSealing

func (*ConsensusCollector) EmergencySeal 

func (cc *ConsensusCollector) EmergencySeal()

EmergencySeal increments the counter of emergency seals.

func (*ConsensusCollector) FinishBlockToSeal 

func (cc *ConsensusCollector) FinishBlockToSeal(blockID flow.Identifier)

FinishBlockToSeal reports Metrics C4: Block Received by CCL → Block Seal in finalized block

func (*ConsensusCollector) FinishCollectionToFinalized 

func (cc *ConsensusCollector) FinishCollectionToFinalized(collectionID flow.Identifier)

FinishCollectionToFinalized reports Metrics C1: Collection Received by CCL→ Collection Included in Finalized Block

func (*ConsensusCollector) OnApprovalProcessingDuration 

func (cc *ConsensusCollector) OnApprovalProcessingDuration(duration time.Duration)

OnApprovalProcessingDuration increases the number of seconds spent processing approvals

func (*ConsensusCollector) OnReceiptProcessingDuration 

func (cc *ConsensusCollector) OnReceiptProcessingDuration(duration time.Duration)

OnReceiptProcessingDuration increases the number of seconds spent processing receipts

func (*ConsensusCollector) StartBlockToSeal 

func (cc *ConsensusCollector) StartBlockToSeal(blockID flow.Identifier)

StartBlockToSeal reports Metrics C4: Block Received by CCL → Block Seal in finalized block

func (*ConsensusCollector) StartCollectionToFinalized 

func (cc *ConsensusCollector) StartCollectionToFinalized(collectionID flow.Identifier)

StartCollectionToFinalized reports Metrics C1: Collection Received by CCL→ Collection Included in Finalized Block

type EngineCollector 

type EngineCollector struct {
	// contains filtered or unexported fields
}

func NewEngineCollector 

func NewEngineCollector() *EngineCollector

func (*EngineCollector) MessageHandled 

func (ec *EngineCollector) MessageHandled(engine string, message string)

func (*EngineCollector) MessageReceived 

func (ec *EngineCollector) MessageReceived(engine string, message string)

func (*EngineCollector) MessageSent 

func (ec *EngineCollector) MessageSent(engine string, message string)

type ExecutionCollector 

type ExecutionCollector struct {
	// contains filtered or unexported fields
}

func NewExecutionCollector 

func NewExecutionCollector(tracer module.Tracer) *ExecutionCollector

func (*ExecutionCollector) ChunkDataPackRequestProcessed 

func (ec *ExecutionCollector) ChunkDataPackRequestProcessed()

ChunkDataPackRequestProcessed is executed every time a chunk data pack request is picked up for processing at execution node. It increases the request processed counter by one.

func (*ExecutionCollector) ExecutionBlockDataUploadFinished 

func (ec *ExecutionCollector) ExecutionBlockDataUploadFinished(dur time.Duration)

func (*ExecutionCollector) ExecutionBlockDataUploadStarted 

func (ec *ExecutionCollector) ExecutionBlockDataUploadStarted()

func (*ExecutionCollector) ExecutionBlockExecuted 

func (ec *ExecutionCollector) ExecutionBlockExecuted(
	dur time.Duration,
	stats module.ExecutionResultStats,
)

ExecutionBlockExecuted reports execution meta data after executing a block

func (*ExecutionCollector) ExecutionBlockExecutionEffortVectorComponent 

func (ec *ExecutionCollector) ExecutionBlockExecutionEffortVectorComponent(compKind string, value uint)

func (*ExecutionCollector) ExecutionChunkDataPackGenerated 

func (ec *ExecutionCollector) ExecutionChunkDataPackGenerated(proofSize, numberOfTransactions int)

ExecutionChunkDataPackGenerated reports stats on chunk data pack generation

func (*ExecutionCollector) ExecutionCollectionExecuted 

func (ec *ExecutionCollector) ExecutionCollectionExecuted(
	dur time.Duration,
	stats module.ExecutionResultStats,
)

ExecutionCollectionExecuted reports stats for executing a collection

func (*ExecutionCollector) ExecutionCollectionRequestRetried 

func (ec *ExecutionCollector) ExecutionCollectionRequestRetried()

func (*ExecutionCollector) ExecutionCollectionRequestSent 

func (ec *ExecutionCollector) ExecutionCollectionRequestSent()

func (*ExecutionCollector) ExecutionComputationResultUploadRetried 

func (ec *ExecutionCollector) ExecutionComputationResultUploadRetried()

func (*ExecutionCollector) ExecutionComputationResultUploaded 

func (ec *ExecutionCollector) ExecutionComputationResultUploaded()

func (*ExecutionCollector) ExecutionLastExecutedBlockHeight 

func (ec *ExecutionCollector) ExecutionLastExecutedBlockHeight(height uint64)

ExecutionLastExecutedBlockHeight reports last executed block height

func (*ExecutionCollector) ExecutionScriptExecuted 

func (ec *ExecutionCollector) ExecutionScriptExecuted(dur time.Duration, compUsed, memoryUsed, memoryEstimated uint64)

ScriptExecuted reports the time spent executing a single script

func (*ExecutionCollector) ExecutionStateStorageDiskTotal 

func (ec *ExecutionCollector) ExecutionStateStorageDiskTotal(bytes int64)

ExecutionStateStorageDiskTotal reports the total storage size of the execution state on disk in bytes

func (*ExecutionCollector) ExecutionStorageStateCommitment 

func (ec *ExecutionCollector) ExecutionStorageStateCommitment(bytes int64)

ExecutionStorageStateCommitment reports the storage size of a state commitment

func (*ExecutionCollector) ExecutionSync 

func (ec *ExecutionCollector) ExecutionSync(syncing bool)

func (*ExecutionCollector) ExecutionTransactionExecuted 

func (ec *ExecutionCollector) ExecutionTransactionExecuted(
	dur time.Duration,
	compUsed, memoryUsed, actualMemoryUsed uint64,
	eventCounts, eventSize int,
	failed bool,
)

TransactionExecuted reports stats for executing a transaction

func (*ExecutionCollector) FinishBlockReceivedToExecuted 

func (ec *ExecutionCollector) FinishBlockReceivedToExecuted(blockID flow.Identifier)

FinishBlockReceivedToExecuted finishes a span to trace the duration of a block from being received for execution to execution being finished

func (*ExecutionCollector) ForestApproxMemorySize 

func (ec *ExecutionCollector) ForestApproxMemorySize(bytes uint64)

ForestApproxMemorySize records approximate memory usage of forest (all in-memory trees)

func (*ExecutionCollector) ForestNumberOfTrees 

func (ec *ExecutionCollector) ForestNumberOfTrees(number uint64)

ForestNumberOfTrees current number of trees in a forest (in memory)

func (*ExecutionCollector) LatestTrieMaxDepthTouched 

func (ec *ExecutionCollector) LatestTrieMaxDepthTouched(maxDepth uint16)

LatestTrieMaxDepthTouched records the maximum depth touched of the last created trie

func (*ExecutionCollector) LatestTrieRegCount 

func (ec *ExecutionCollector) LatestTrieRegCount(number uint64)

LatestTrieRegCount records the number of unique register allocated (the lastest created trie)

func (*ExecutionCollector) LatestTrieRegCountDiff 

func (ec *ExecutionCollector) LatestTrieRegCountDiff(number int64)

LatestTrieRegCountDiff records the difference between the number of unique register allocated of the latest created trie and parent trie

func (*ExecutionCollector) LatestTrieRegSize 

func (ec *ExecutionCollector) LatestTrieRegSize(size uint64)

LatestTrieRegSize records the size of unique register allocated (the lastest created trie)

func (*ExecutionCollector) LatestTrieRegSizeDiff 

func (ec *ExecutionCollector) LatestTrieRegSizeDiff(size int64)

LatestTrieRegSizeDiff records the difference between the size of unique register allocated of the latest created trie and parent trie

func (*ExecutionCollector) ProofSize 

func (ec *ExecutionCollector) ProofSize(bytes uint32)

ProofSize records a proof size

func (*ExecutionCollector) ReadDuration 

func (ec *ExecutionCollector) ReadDuration(duration time.Duration)

ReadDuration records absolute time for the read from a trie

func (*ExecutionCollector) ReadDurationPerItem 

func (ec *ExecutionCollector) ReadDurationPerItem(duration time.Duration)

ReadDurationPerItem records read time for single value (total duration / number of read values)

func (*ExecutionCollector) ReadValuesNumber 

func (ec *ExecutionCollector) ReadValuesNumber(number uint64)

ReadValuesNumber accumulates number of read values

func (*ExecutionCollector) ReadValuesSize 

func (ec *ExecutionCollector) ReadValuesSize(bytes uint64)

ReadValuesSize total size (in bytes) of read values

func (*ExecutionCollector) RuntimeSetNumberOfAccounts 

func (ec *ExecutionCollector) RuntimeSetNumberOfAccounts(count uint64)

func (*ExecutionCollector) RuntimeTransactionChecked 

func (ec *ExecutionCollector) RuntimeTransactionChecked(dur time.Duration)

TransactionChecked reports the time spent checking a single transaction

func (*ExecutionCollector) RuntimeTransactionInterpreted 

func (ec *ExecutionCollector) RuntimeTransactionInterpreted(dur time.Duration)

TransactionInterpreted reports the time spent interpreting a single transaction

func (*ExecutionCollector) RuntimeTransactionParsed 

func (ec *ExecutionCollector) RuntimeTransactionParsed(dur time.Duration)

TransactionParsed reports the time spent parsing a single transaction

func (*ExecutionCollector) StartBlockReceivedToExecuted 

func (ec *ExecutionCollector) StartBlockReceivedToExecuted(blockID flow.Identifier)

StartBlockReceivedToExecuted starts a span to trace the duration of a block from being received for execution to execution being finished

func (*ExecutionCollector) UpdateCollectionMaxHeight 

func (ec *ExecutionCollector) UpdateCollectionMaxHeight(height uint64)

func (*ExecutionCollector) UpdateCount 

func (ec *ExecutionCollector) UpdateCount()

UpdateCount increase a counter of performed updates

func (*ExecutionCollector) UpdateDuration 

func (ec *ExecutionCollector) UpdateDuration(duration time.Duration)

UpdateDuration records absolute time for the update of a trie

func (*ExecutionCollector) UpdateDurationPerItem 

func (ec *ExecutionCollector) UpdateDurationPerItem(duration time.Duration)

UpdateDurationPerItem records update time for single value (total duration / number of updated values)

func (*ExecutionCollector) UpdateValuesNumber 

func (ec *ExecutionCollector) UpdateValuesNumber(number uint64)

UpdateValuesNumber accumulates number of updated values

func (*ExecutionCollector) UpdateValuesSize 

func (ec *ExecutionCollector) UpdateValuesSize(bytes uint64)

UpdateValuesSize total size (in bytes) of updates values

type ExecutionDataProviderCollector 

type ExecutionDataProviderCollector struct {
	// contains filtered or unexported fields
}

func NewExecutionDataProviderCollector 

func NewExecutionDataProviderCollector() *ExecutionDataProviderCollector

func (*ExecutionDataProviderCollector) AddBlobsFailed 

func (c *ExecutionDataProviderCollector) AddBlobsFailed()

func (*ExecutionDataProviderCollector) AddBlobsSucceeded 

func (c *ExecutionDataProviderCollector) AddBlobsSucceeded(duration time.Duration, totalSize uint64)

func (*ExecutionDataProviderCollector) RootIDComputed 

func (c *ExecutionDataProviderCollector) RootIDComputed(duration time.Duration, numberOfChunks int)

type ExecutionDataPrunerCollector 

type ExecutionDataPrunerCollector struct {
	// contains filtered or unexported fields
}

func NewExecutionDataPrunerCollector 

func NewExecutionDataPrunerCollector() *ExecutionDataPrunerCollector

func (*ExecutionDataPrunerCollector) Pruned 

func (c *ExecutionDataPrunerCollector) Pruned(height uint64, duration time.Duration)

type ExecutionDataRequesterCollector 

type ExecutionDataRequesterCollector struct {
	// contains filtered or unexported fields
}

func (*ExecutionDataRequesterCollector) ExecutionDataFetchFinished 

func (ec *ExecutionDataRequesterCollector) ExecutionDataFetchFinished(duration time.Duration, success bool, height uint64)

func (*ExecutionDataRequesterCollector) ExecutionDataFetchStarted 

func (ec *ExecutionDataRequesterCollector) ExecutionDataFetchStarted()

func (*ExecutionDataRequesterCollector) FetchRetried 

func (ec *ExecutionDataRequesterCollector) FetchRetried()

func (*ExecutionDataRequesterCollector) NotificationSent 

func (ec *ExecutionDataRequesterCollector) NotificationSent(height uint64)

type ExecutionDataRequesterV2Collector 

type ExecutionDataRequesterV2Collector struct {
	// contains filtered or unexported fields
}

func NewExecutionDataRequesterV2Collector 

func NewExecutionDataRequesterV2Collector() *ExecutionDataRequesterV2Collector

func (*ExecutionDataRequesterV2Collector) FulfilledHeight 

func (c *ExecutionDataRequesterV2Collector) FulfilledHeight(blockHeight uint64)

func (*ExecutionDataRequesterV2Collector) ReceiptSkipped 

func (c *ExecutionDataRequesterV2Collector) ReceiptSkipped()

func (*ExecutionDataRequesterV2Collector) RequestCanceled 

func (c *ExecutionDataRequesterV2Collector) RequestCanceled()

func (*ExecutionDataRequesterV2Collector) RequestFailed 

func (c *ExecutionDataRequesterV2Collector) RequestFailed(duration time.Duration, retryable bool)

func (*ExecutionDataRequesterV2Collector) RequestSucceeded 

func (c *ExecutionDataRequesterV2Collector) RequestSucceeded(blockHeight uint64, duration time.Duration, totalSize uint64, numberOfAttempts int)

func (*ExecutionDataRequesterV2Collector) ResponseDropped 

func (c *ExecutionDataRequesterV2Collector) ResponseDropped()

type GossipSubMetrics 

type GossipSubMetrics struct {
	// contains filtered or unexported fields
}

func NewGossipSubMetrics 

func NewGossipSubMetrics(prefix string) *GossipSubMetrics

func (*GossipSubMetrics) OnGraftReceived 

func (nc *GossipSubMetrics) OnGraftReceived(count int)

OnGraftReceived tracks the number of GRAFT messages received by the node from other nodes. GRAFT is a control message of GossipSub protocol that connects two nodes over a topic directly as gossip partners.

func (*GossipSubMetrics) OnIHaveReceived 

func (nc *GossipSubMetrics) OnIHaveReceived(count int)

OnIHaveReceived tracks the number of IHAVE messages received by the node from other nodes. iHave is a control message that is sent by a node to another node to indicate that it has a new gossiped message.

func (*GossipSubMetrics) OnIWantReceived 

func (nc *GossipSubMetrics) OnIWantReceived(count int)

OnIWantReceived tracks the number of IWANT messages received by the node from other nodes. iWant is a control message that is sent by a node to request a message that it has seen advertised in an iHAVE message.

func (*GossipSubMetrics) OnIncomingRpcAcceptedFully 

func (nc *GossipSubMetrics) OnIncomingRpcAcceptedFully()

OnIncomingRpcAcceptedFully tracks the number of RPC messages received by the node that are fully accepted. An RPC may contain any number of control messages, i.e., IHAVE, IWANT, GRAFT, PRUNE, as well as the actual messages. A fully accepted RPC means that all the control messages are accepted and all the messages are accepted.

func (*GossipSubMetrics) OnIncomingRpcAcceptedOnlyForControlMessages 

func (nc *GossipSubMetrics) OnIncomingRpcAcceptedOnlyForControlMessages()

OnIncomingRpcAcceptedOnlyForControlMessages tracks the number of RPC messages received by the node that are accepted only for the control messages, i.e., only for the included IHAVE, IWANT, GRAFT, PRUNE. However, the actual messages included in the RPC are not accepted. This happens mostly when the validation pipeline of GossipSub is throttled, and cannot accept more actual messages for validation.

func (*GossipSubMetrics) OnIncomingRpcRejected 

func (nc *GossipSubMetrics) OnIncomingRpcRejected()

OnIncomingRpcRejected tracks the number of RPC messages received by the node that are rejected. This happens mostly when the RPC is coming from a low-scored peer based on the peer scoring module of GossipSub.

func (*GossipSubMetrics) OnPruneReceived 

func (nc *GossipSubMetrics) OnPruneReceived(count int)

OnPruneReceived tracks the number of PRUNE messages received by the node from other nodes. PRUNE is a control message of GossipSub protocol that disconnects two nodes over a topic.

func (*GossipSubMetrics) OnPublishedGossipMessagesReceived 

func (nc *GossipSubMetrics) OnPublishedGossipMessagesReceived(count int)

OnPublishedGossipMessagesReceived tracks the number of gossip messages received by the node from other nodes over an RPC message.

type HeroCacheCollector 

type HeroCacheCollector struct {
	// contains filtered or unexported fields
}

func ChunkDataPackRequestQueueMetricsFactory 

func ChunkDataPackRequestQueueMetricsFactory(registrar prometheus.Registerer) *HeroCacheCollector

func CollectionNodeTransactionsCacheMetrics 

func CollectionNodeTransactionsCacheMetrics(registrar prometheus.Registerer, epoch uint64) *HeroCacheCollector

func CollectionRequestsQueueMetricFactory 

func CollectionRequestsQueueMetricFactory(registrar prometheus.Registerer) *HeroCacheCollector

func NetworkDnsIpCacheMetricsFactory 

func NetworkDnsIpCacheMetricsFactory(registrar prometheus.Registerer) *HeroCacheCollector

func NetworkDnsTxtCacheMetricsFactory 

func NetworkDnsTxtCacheMetricsFactory(registrar prometheus.Registerer) *HeroCacheCollector

func NetworkReceiveCacheMetricsFactory 

func NetworkReceiveCacheMetricsFactory(registrar prometheus.Registerer) *HeroCacheCollector

func NewHeroCacheCollector 

func NewHeroCacheCollector(nameSpace string, cacheName string, registrar prometheus.Registerer) *HeroCacheCollector

func PublicNetworkReceiveCacheMetricsFactory 

func PublicNetworkReceiveCacheMetricsFactory(registrar prometheus.Registerer) *HeroCacheCollector

func ReceiptRequestsQueueMetricFactory 

func ReceiptRequestsQueueMetricFactory(registrar prometheus.Registerer) *HeroCacheCollector

func (*HeroCacheCollector) BucketAvailableSlots 

func (h *HeroCacheCollector) BucketAvailableSlots(availableSlots uint64, totalSlots uint64)

BucketAvailableSlots keeps track of number of available slots in buckets of cache.

func (*HeroCacheCollector) OnEntityEjectionDueToEmergency 

func (h *HeroCacheCollector) OnEntityEjectionDueToEmergency()

OnEntityEjectionDueToEmergency is called whenever a bucket is found full and all of its keys are valid, i.e., each key belongs to an existing (key, entity) pair. Hence, adding a new key to that bucket will replace the oldest valid key inside that bucket. Note: in context of HeroCache, the key corresponds to the identifier of its entity.

func (*HeroCacheCollector) OnEntityEjectionDueToFullCapacity 

func (h *HeroCacheCollector) OnEntityEjectionDueToFullCapacity()

OnEntityEjectionDueToFullCapacity is called whenever adding a new (key, entity) to the cache results in ejection of another (key', entity') pair. This normally happens -- and is expected -- when the cache is full. Note: in context of HeroCache, the key corresponds to the identifier of its entity.

func (*HeroCacheCollector) OnKeyGetFailure 

func (h *HeroCacheCollector) OnKeyGetFailure()

OnKeyGetFailure tracks total number of unsuccessful read queries. A read query is unsuccessful if the entity corresponding to its key is not available in the cache. Note: in context of HeroCache, the key corresponds to the identifier of its entity.

func (*HeroCacheCollector) OnKeyGetSuccess 

func (h *HeroCacheCollector) OnKeyGetSuccess()

OnKeyGetSuccess tracks total number of successful read queries. A read query is successful if the entity corresponding to its key is available in the cache. Note: in context of HeroCache, the key corresponds to the identifier of its entity.

func (*HeroCacheCollector) OnKeyPutAttempt 

func (h *HeroCacheCollector) OnKeyPutAttempt(size uint32)

OnKeyPutAttempt is called whenever a new (key, value) pair is attempted to be put in cache. It does not reflect whether the put was successful or not. A (key, value) pair put attempt may fail if the cache is full, or the key already exists. size parameter is the current size of the cache prior to the put attempt.

func (*HeroCacheCollector) OnKeyPutDeduplicated 

func (h *HeroCacheCollector) OnKeyPutDeduplicated()

OnKeyPutDeduplicated is tracking the total number of unsuccessful writes caused by adding a duplicate key to the cache. A duplicate key is dropped by the cache when it is written to the cache. Note: in context of HeroCache, the key corresponds to the identifier of its entity. Hence, a duplicate key corresponds to a duplicate entity.

func (*HeroCacheCollector) OnKeyPutDrop 

func (h *HeroCacheCollector) OnKeyPutDrop()

OnKeyPutDrop is called whenever a new (key, entity) pair is dropped from the cache due to full cache.

func (*HeroCacheCollector) OnKeyPutSuccess 

func (h *HeroCacheCollector) OnKeyPutSuccess(size uint32)

OnKeyPutSuccess is called whenever a new (key, entity) pair is successfully added to the cache. size parameter is the current size of the cache post insertion.

func (*HeroCacheCollector) OnKeyRemoved 

func (h *HeroCacheCollector) OnKeyRemoved(size uint32)

OnKeyRemoved is called whenever a (key, entity) pair is removed from the cache. size parameter is the current size of the cache.

type HeroCacheMetricsRegistrationFunc 

type HeroCacheMetricsRegistrationFunc func(uint64) module.HeroCacheMetrics

type HotstuffCollector 

type HotstuffCollector struct {
	// contains filtered or unexported fields
}

HotstuffCollector implements only the metrics emitted by the HotStuff core logic. We have multiple instances of HotStuff running within Flow: Consensus Nodes form the main consensus committee. In addition each Collector node cluster runs their own HotStuff instance. Depending on the node role, the name space is different. Furthermore, even within the `collection` name space, we need to separate metrics between the different clusters. We do this by adding the label `committeeID` to the HotStuff metrics and allowing for configurable name space.

func NewHotstuffCollector 

func NewHotstuffCollector(chain flow.ChainID) *HotstuffCollector

func (*HotstuffCollector) CommitteeProcessingDuration 

func (hc *HotstuffCollector) CommitteeProcessingDuration(duration time.Duration)

CommitteeProcessingDuration measures the time which the HotStuff's core logic spends in the hotstuff.Committee component, i.e. the time determining consensus committee relations.

func (*HotstuffCollector) CountSkipped 

func (hc *HotstuffCollector) CountSkipped()

CountSkipped counts the number of skips we did.

func (*HotstuffCollector) CountTimeout 

func (hc *HotstuffCollector) CountTimeout()

CountTimeout counts the number of timeouts we had.

func (*HotstuffCollector) HotStuffBusyDuration 

func (hc *HotstuffCollector) HotStuffBusyDuration(duration time.Duration, event string)

HotStuffBusyDuration reports Metrics C6 HotStuff Busy Duration

func (*HotstuffCollector) HotStuffIdleDuration 

func (hc *HotstuffCollector) HotStuffIdleDuration(duration time.Duration)

HotStuffIdleDuration reports Metrics C6 HotStuff Idle Duration

func (*HotstuffCollector) HotStuffWaitDuration 

func (hc *HotstuffCollector) HotStuffWaitDuration(duration time.Duration, event string)

HotStuffWaitDuration reports Metrics C6 HotStuff Wait Duration

func (*HotstuffCollector) PayloadProductionDuration 

func (hc *HotstuffCollector) PayloadProductionDuration(duration time.Duration)

PayloadProductionDuration reports the time which the HotStuff's core logic spends in the module.Builder component, i.e. the with generating block payloads

func (*HotstuffCollector) SetCurView 

func (hc *HotstuffCollector) SetCurView(view uint64)

HotstuffCollector reports Metrics C8: Current View

func (*HotstuffCollector) SetQCView 

func (hc *HotstuffCollector) SetQCView(view uint64)

NewestKnownQC reports Metrics C9: View of Newest Known QC

func (*HotstuffCollector) SetTimeout 

func (hc *HotstuffCollector) SetTimeout(duration time.Duration)

SetTimeout sets the current timeout duration.

func (*HotstuffCollector) SignerProcessingDuration 

func (hc *HotstuffCollector) SignerProcessingDuration(duration time.Duration)

SignerProcessingDuration reports the time which the HotStuff's core logic spends in the hotstuff.Signer component, i.e. the with crypto-related operations.

func (*HotstuffCollector) ValidatorProcessingDuration 

func (hc *HotstuffCollector) ValidatorProcessingDuration(duration time.Duration)

ValidatorProcessingDuration reports the time which the HotStuff's core logic spends in the hotstuff.Validator component, i.e. the with verifying higher-level consensus messages.

type LibP2PResourceManagerMetrics 

type LibP2PResourceManagerMetrics struct {
	// contains filtered or unexported fields
}

func NewLibP2PResourceManagerMetrics 

func NewLibP2PResourceManagerMetrics(logger zerolog.Logger, prefix string) *LibP2PResourceManagerMetrics

func (*LibP2PResourceManagerMetrics) AllowConn 

func (l *LibP2PResourceManagerMetrics) AllowConn(dir network.Direction, usefd bool)

func (*LibP2PResourceManagerMetrics) AllowMemory 

func (l *LibP2PResourceManagerMetrics) AllowMemory(size int)

func (*LibP2PResourceManagerMetrics) AllowPeer 

func (l *LibP2PResourceManagerMetrics) AllowPeer(p peer.ID)

func (*LibP2PResourceManagerMetrics) AllowProtocol 

func (l *LibP2PResourceManagerMetrics) AllowProtocol(proto protocol.ID)

func (*LibP2PResourceManagerMetrics) AllowService 

func (l *LibP2PResourceManagerMetrics) AllowService(svc string)

func (*LibP2PResourceManagerMetrics) AllowStream 

func (l *LibP2PResourceManagerMetrics) AllowStream(p peer.ID, dir network.Direction)

func (*LibP2PResourceManagerMetrics) BlockConn 

func (l *LibP2PResourceManagerMetrics) BlockConn(dir network.Direction, usefd bool)

func (*LibP2PResourceManagerMetrics) BlockMemory 

func (l *LibP2PResourceManagerMetrics) BlockMemory(size int)

func (*LibP2PResourceManagerMetrics) BlockPeer 

func (l *LibP2PResourceManagerMetrics) BlockPeer(p peer.ID)

func (*LibP2PResourceManagerMetrics) BlockProtocol 

func (l *LibP2PResourceManagerMetrics) BlockProtocol(proto protocol.ID)

func (*LibP2PResourceManagerMetrics) BlockProtocolPeer 

func (l *LibP2PResourceManagerMetrics) BlockProtocolPeer(proto protocol.ID, p peer.ID)

func (*LibP2PResourceManagerMetrics) BlockService 

func (l *LibP2PResourceManagerMetrics) BlockService(svc string)

func (*LibP2PResourceManagerMetrics) BlockServicePeer 

func (l *LibP2PResourceManagerMetrics) BlockServicePeer(svc string, p peer.ID)

func (*LibP2PResourceManagerMetrics) BlockStream 

func (l *LibP2PResourceManagerMetrics) BlockStream(p peer.ID, dir network.Direction)

type LoaderCollector 

type LoaderCollector struct {
	// contains filtered or unexported fields
}

func NewLoaderCollector 

func NewLoaderCollector() *LoaderCollector

func (*LoaderCollector) SetTPSConfigured 

func (cc *LoaderCollector) SetTPSConfigured(tps uint)

func (*LoaderCollector) TransactionExecuted 

func (cc *LoaderCollector) TransactionExecuted(duration time.Duration)

func (*LoaderCollector) TransactionLost 

func (cc *LoaderCollector) TransactionLost()

func (*LoaderCollector) TransactionSent 

func (cc *LoaderCollector) TransactionSent()

type MempoolCollector 

type MempoolCollector struct {
	// contains filtered or unexported fields
}

func NewMempoolCollector 

func NewMempoolCollector(interval time.Duration) *MempoolCollector

func (*MempoolCollector) Done 

func (mc *MempoolCollector) Done() <-chan struct{}

func (*MempoolCollector) MempoolEntries 

func (mc *MempoolCollector) MempoolEntries(resource string, entries uint)

func (*MempoolCollector) Ready 

func (mc *MempoolCollector) Ready() <-chan struct{}

func (*MempoolCollector) Register 

func (mc *MempoolCollector) Register(resource string, entriesFunc module.EntriesFunc) error

Register registers entriesFunc for a resource

type NetworkCollector 

type NetworkCollector struct {
	*LibP2PResourceManagerMetrics
	*GossipSubMetrics
	// contains filtered or unexported fields
}

func NewNetworkCollector 

func NewNetworkCollector(logger zerolog.Logger, opts ...NetworkCollectorOpt) *NetworkCollector

func (*NetworkCollector) DNSLookupDuration 

func (nc *NetworkCollector) DNSLookupDuration(duration time.Duration)

DNSLookupDuration tracks the time spent to resolve a DNS address.

func (*NetworkCollector) DuplicateInboundMessagesDropped 

func (nc *NetworkCollector) DuplicateInboundMessagesDropped(topic, protocol, messageType string)

DuplicateInboundMessagesDropped increments the metric tracking the number of duplicate messages dropped by the node.

func (*NetworkCollector) InboundConnections 

func (nc *NetworkCollector) InboundConnections(connectionCount uint)

InboundConnections updates the metric tracking the number of inbound connections of this node

func (*NetworkCollector) InboundMessageReceived 

func (nc *NetworkCollector) InboundMessageReceived(sizeBytes int, topic, protocol, messageType string)

InboundMessageReceived collects metrics related to a message received by the node.

func (*NetworkCollector) MessageAdded 

func (nc *NetworkCollector) MessageAdded(priority int)

func (*NetworkCollector) MessageProcessingFinished 

func (nc *NetworkCollector) MessageProcessingFinished(topic string, duration time.Duration)

MessageProcessingFinished tracks the time spent by the node to process a message and decrements the metric tracking the number of messages being processed by the node.

func (*NetworkCollector) MessageProcessingStarted 

func (nc *NetworkCollector) MessageProcessingStarted(topic string)

MessageProcessingStarted increments the metric tracking the number of messages being processed by the node.

func (*NetworkCollector) MessageRemoved 

func (nc *NetworkCollector) MessageRemoved(priority int)

func (*NetworkCollector) OnDNSCacheHit 

func (nc *NetworkCollector) OnDNSCacheHit()

OnDNSCacheHit tracks the total number of dns requests resolved through the cache without looking up the network.

func (*NetworkCollector) OnDNSCacheInvalidated 

func (nc *NetworkCollector) OnDNSCacheInvalidated()

OnDNSCacheInvalidated is called whenever dns cache is invalidated for an entry

func (*NetworkCollector) OnDNSCacheMiss 

func (nc *NetworkCollector) OnDNSCacheMiss()

OnDNSCacheMiss tracks the total number of dns requests resolved through looking up the network.

func (*NetworkCollector) OnDNSLookupRequestDropped 

func (nc *NetworkCollector) OnDNSLookupRequestDropped()

OnDNSLookupRequestDropped tracks the number of dns lookup requests that are dropped due to a full queue

func (*NetworkCollector) OnRateLimitedUnicastMessage 

func (nc *NetworkCollector) OnRateLimitedUnicastMessage(role, msgType, topic, reason string)

OnRateLimitedUnicastMessage tracks the number of rate limited messages seen on the network.

func (*NetworkCollector) OnUnauthorizedMessage 

func (nc *NetworkCollector) OnUnauthorizedMessage(role, msgType, topic, offense string)

OnUnauthorizedMessage tracks the number of unauthorized messages seen on the network.

func (*NetworkCollector) OutboundConnections 

func (nc *NetworkCollector) OutboundConnections(connectionCount uint)

OutboundConnections updates the metric tracking the number of outbound connections of this node

func (*NetworkCollector) OutboundMessageSent 

func (nc *NetworkCollector) OutboundMessageSent(sizeBytes int, topic, protocol, messageType string)

OutboundMessageSent collects metrics related to a message sent by the node.

func (*NetworkCollector) QueueDuration 

func (nc *NetworkCollector) QueueDuration(duration time.Duration, priority int)

func (*NetworkCollector) RoutingTablePeerAdded 

func (nc *NetworkCollector) RoutingTablePeerAdded()

func (*NetworkCollector) RoutingTablePeerRemoved 

func (nc *NetworkCollector) RoutingTablePeerRemoved()

func (*NetworkCollector) UnicastMessageSendingCompleted 

func (nc *NetworkCollector) UnicastMessageSendingCompleted(topic string)

UnicastMessageSendingCompleted decrements the metric tracking the number of unicast messages sent by the node.

func (*NetworkCollector) UnicastMessageSendingStarted 

func (nc *NetworkCollector) UnicastMessageSendingStarted(topic string)

UnicastMessageSendingStarted increments the metric tracking the number of unicast messages sent by the node.

type NetworkCollectorOpt 

type NetworkCollectorOpt func(*NetworkCollector)

func WithNetworkPrefix 

func WithNetworkPrefix(prefix string) NetworkCollectorOpt

type NodeInfoCollector 

type NodeInfoCollector struct {
	// contains filtered or unexported fields
}

NodeInfoCollector implements metrics to report static information about node. Such information can include: version, commit, sporkID.

func NewNodeInfoCollector 

func NewNodeInfoCollector() *NodeInfoCollector

func (*NodeInfoCollector) NodeInfo 

func (sc *NodeInfoCollector) NodeInfo(version, commit, sporkID string, protocolVersion uint)

type NoopCollector 

type NoopCollector struct{}

func NewNoopCollector 

func NewNoopCollector() *NoopCollector

func (*NoopCollector) AddBlobsFailed 

func (nc *NoopCollector) AddBlobsFailed()

func (*NoopCollector) AddBlobsSucceeded 

func (nc *NoopCollector) AddBlobsSucceeded(duration time.Duration, totalSize uint64)

func (*NoopCollector) AllowConn 

func (nc *NoopCollector) AllowConn(dir network.Direction, usefd bool)

func (*NoopCollector) AllowMemory 

func (nc *NoopCollector) AllowMemory(size int)

func (*NoopCollector) AllowPeer 

func (nc *NoopCollector) AllowPeer(p peer.ID)

func (*NoopCollector) AllowProtocol 

func (nc *NoopCollector) AllowProtocol(proto protocol.ID)

func (*NoopCollector) AllowService 

func (nc *NoopCollector) AllowService(svc string)

func (*NoopCollector) AllowStream 

func (nc *NoopCollector) AllowStream(p peer.ID, dir network.Direction)

func (*NoopCollector) BadgerLSMSize 

func (nc *NoopCollector) BadgerLSMSize(sizeBytes int64)

func (*NoopCollector) BadgerNumBlockedPuts 

func (nc *NoopCollector) BadgerNumBlockedPuts(n int64)

func (*NoopCollector) BadgerNumBytesRead 

func (nc *NoopCollector) BadgerNumBytesRead(n int64)

func (*NoopCollector) BadgerNumBytesWritten 

func (nc *NoopCollector) BadgerNumBytesWritten(n int64)

func (*NoopCollector) BadgerNumGets 

func (nc *NoopCollector) BadgerNumGets(n int64)

func (*NoopCollector) BadgerNumMemtableGets 

func (nc *NoopCollector) BadgerNumMemtableGets(n int64)

func (*NoopCollector) BadgerNumPuts 

func (nc *NoopCollector) BadgerNumPuts(n int64)

func (*NoopCollector) BadgerNumReads 

func (nc *NoopCollector) BadgerNumReads(n int64)

func (*NoopCollector) BadgerNumWrites 

func (nc *NoopCollector) BadgerNumWrites(n int64)

func (*NoopCollector) BadgerVLogSize 

func (nc *NoopCollector) BadgerVLogSize(sizeBytes int64)

func (*NoopCollector) BatchRequested 

func (nc *NoopCollector) BatchRequested(batch chainsync.Batch)

func (*NoopCollector) BlobsReceived 

func (nc *NoopCollector) BlobsReceived(prefix string, n uint64)

func (*NoopCollector) BlobsSent 

func (nc *NoopCollector) BlobsSent(prefix string, n uint64)

func (*NoopCollector) BlockConn 

func (nc *NoopCollector) BlockConn(dir network.Direction, usefd bool)

func (*NoopCollector) BlockFinalized 

func (nc *NoopCollector) BlockFinalized(*flow.Block)

func (*NoopCollector) BlockMemory 

func (nc *NoopCollector) BlockMemory(size int)

func (*NoopCollector) BlockPeer 

func (nc *NoopCollector) BlockPeer(p peer.ID)

func (*NoopCollector) BlockProposalDuration 

func (nc *NoopCollector) BlockProposalDuration(duration time.Duration)

func (*NoopCollector) BlockProposed 

func (nc *NoopCollector) BlockProposed(*flow.Block)

func (*NoopCollector) BlockProtocol 

func (nc *NoopCollector) BlockProtocol(proto protocol.ID)

func (*NoopCollector) BlockProtocolPeer 

func (nc *NoopCollector) BlockProtocolPeer(proto protocol.ID, p peer.ID)

func (*NoopCollector) BlockSealed 

func (nc *NoopCollector) BlockSealed(*flow.Block)

func (*NoopCollector) BlockService 

func (nc *NoopCollector) BlockService(svc string)

func (*NoopCollector) BlockServicePeer 

func (nc *NoopCollector) BlockServicePeer(svc string, p peer.ID)

func (*NoopCollector) BlockStream 

func (nc *NoopCollector) BlockStream(p peer.ID, dir network.Direction)

func (*NoopCollector) BucketAvailableSlots 

func (nc *NoopCollector) BucketAvailableSlots(uint64, uint64)

func (*NoopCollector) CacheEntries 

func (nc *NoopCollector) CacheEntries(resource string, entries uint)

func (*NoopCollector) CacheHit 

func (nc *NoopCollector) CacheHit(resource string)

func (*NoopCollector) CacheMiss 

func (nc *NoopCollector) CacheMiss(resource string)

func (*NoopCollector) CacheNotFound 

func (nc *NoopCollector) CacheNotFound(resource string)

func (*NoopCollector) CheckSealingDuration 

func (nc *NoopCollector) CheckSealingDuration(duration time.Duration)

func (*NoopCollector) ChunkDataPackRequestProcessed 

func (nc *NoopCollector) ChunkDataPackRequestProcessed()

func (*NoopCollector) ClusterBlockFinalized 

func (nc *NoopCollector) ClusterBlockFinalized(*cluster.Block)

func (*NoopCollector) ClusterBlockProposed 

func (nc *NoopCollector) ClusterBlockProposed(*cluster.Block)

func (*NoopCollector) CommittedEpochFinalView 

func (nc *NoopCollector) CommittedEpochFinalView(view uint64)

func (*NoopCollector) CommitteeProcessingDuration 

func (nc *NoopCollector) CommitteeProcessingDuration(duration time.Duration)

func (*NoopCollector) ConnectionAddedToPool 

func (nc *NoopCollector) ConnectionAddedToPool()

func (*NoopCollector) ConnectionFromPoolEvicted 

func (nc *NoopCollector) ConnectionFromPoolEvicted()

func (*NoopCollector) ConnectionFromPoolInvalidated 

func (nc *NoopCollector) ConnectionFromPoolInvalidated()

func (*NoopCollector) ConnectionFromPoolReused 

func (nc *NoopCollector) ConnectionFromPoolReused()

func (*NoopCollector) ConnectionFromPoolUpdated 

func (nc *NoopCollector) ConnectionFromPoolUpdated()

func (*NoopCollector) CountSkipped 

func (nc *NoopCollector) CountSkipped()

func (*NoopCollector) CountTimeout 

func (nc *NoopCollector) CountTimeout()

func (*NoopCollector) CurrentDKGPhase1FinalView 

func (nc *NoopCollector) CurrentDKGPhase1FinalView(view uint64)

func (*NoopCollector) CurrentDKGPhase2FinalView 

func (nc *NoopCollector) CurrentDKGPhase2FinalView(view uint64)

func (*NoopCollector) CurrentDKGPhase3FinalView 

func (nc *NoopCollector) CurrentDKGPhase3FinalView(view uint64)

func (*NoopCollector) CurrentEpochCounter 

func (nc *NoopCollector) CurrentEpochCounter(counter uint64)

func (*NoopCollector) CurrentEpochFinalView 

func (nc *NoopCollector) CurrentEpochFinalView(view uint64)

func (*NoopCollector) CurrentEpochPhase 

func (nc *NoopCollector) CurrentEpochPhase(phase flow.EpochPhase)

func (*NoopCollector) DNSLookupDuration 

func (nc *NoopCollector) DNSLookupDuration(duration time.Duration)

func (*NoopCollector) DataReceived 

func (nc *NoopCollector) DataReceived(prefix string, n uint64)

func (*NoopCollector) DataSent 

func (nc *NoopCollector) DataSent(prefix string, n uint64)

func (*NoopCollector) DupBlobsReceived 

func (nc *NoopCollector) DupBlobsReceived(prefix string, n uint64)

func (*NoopCollector) DupDataReceived 

func (nc *NoopCollector) DupDataReceived(prefix string, n uint64)

func (*NoopCollector) DuplicateInboundMessagesDropped 

func (nc *NoopCollector) DuplicateInboundMessagesDropped(string, string, string)

func (*NoopCollector) EmergencySeal 

func (nc *NoopCollector) EmergencySeal()

func (*NoopCollector) EpochEmergencyFallbackTriggered 

func (nc *NoopCollector) EpochEmergencyFallbackTriggered()

func (*NoopCollector) ExecutionBlockDataUploadFinished 

func (nc *NoopCollector) ExecutionBlockDataUploadFinished(dur time.Duration)

func (*NoopCollector) ExecutionBlockDataUploadStarted 

func (nc *NoopCollector) ExecutionBlockDataUploadStarted()

func (*NoopCollector) ExecutionBlockExecuted 

func (nc *NoopCollector) ExecutionBlockExecuted(_ time.Duration, _ module.ExecutionResultStats)

func (*NoopCollector) ExecutionBlockExecutionEffortVectorComponent 

func (nc *NoopCollector) ExecutionBlockExecutionEffortVectorComponent(_ string, _ uint)

func (*NoopCollector) ExecutionChunkDataPackGenerated 

func (nc *NoopCollector) ExecutionChunkDataPackGenerated(_, _ int)

func (*NoopCollector) ExecutionCollectionExecuted 

func (nc *NoopCollector) ExecutionCollectionExecuted(_ time.Duration, _ module.ExecutionResultStats)

func (*NoopCollector) ExecutionCollectionRequestRetried 

func (nc *NoopCollector) ExecutionCollectionRequestRetried()

func (*NoopCollector) ExecutionCollectionRequestSent 

func (nc *NoopCollector) ExecutionCollectionRequestSent()

func (*NoopCollector) ExecutionComputationResultUploadRetried 

func (nc *NoopCollector) ExecutionComputationResultUploadRetried()

func (*NoopCollector) ExecutionComputationResultUploaded 

func (nc *NoopCollector) ExecutionComputationResultUploaded()

func (*NoopCollector) ExecutionComputationUsedPerBlock 

func (nc *NoopCollector) ExecutionComputationUsedPerBlock(computation uint64)

func (*NoopCollector) ExecutionDataFetchFinished 

func (nc *NoopCollector) ExecutionDataFetchFinished(_ time.Duration, _ bool, _ uint64)

func (*NoopCollector) ExecutionDataFetchStarted 

func (nc *NoopCollector) ExecutionDataFetchStarted()

func (*NoopCollector) ExecutionLastExecutedBlockHeight 

func (nc *NoopCollector) ExecutionLastExecutedBlockHeight(height uint64)

func (*NoopCollector) ExecutionScriptExecuted 

func (nc *NoopCollector) ExecutionScriptExecuted(dur time.Duration, compUsed, _, _ uint64)

func (*NoopCollector) ExecutionStorageStateCommitment 

func (nc *NoopCollector) ExecutionStorageStateCommitment(bytes int64)

func (*NoopCollector) ExecutionSync 

func (nc *NoopCollector) ExecutionSync(syncing bool)

func (*NoopCollector) ExecutionTransactionExecuted 

func (nc *NoopCollector) ExecutionTransactionExecuted(_ time.Duration, _, _, _ uint64, _, _ int, _ bool)

func (*NoopCollector) FetchRetried 

func (nc *NoopCollector) FetchRetried()

func (*NoopCollector) FinalizedHeight 

func (nc *NoopCollector) FinalizedHeight(height uint64)

func (*NoopCollector) FinishBlockReceivedToExecuted 

func (nc *NoopCollector) FinishBlockReceivedToExecuted(blockID flow.Identifier)

func (*NoopCollector) FinishBlockToSeal 

func (nc *NoopCollector) FinishBlockToSeal(blockID flow.Identifier)

func (*NoopCollector) FinishCollectionToFinalized 

func (nc *NoopCollector) FinishCollectionToFinalized(collectionID flow.Identifier)

func (*NoopCollector) ForestApproxMemorySize 

func (nc *NoopCollector) ForestApproxMemorySize(bytes uint64)

func (*NoopCollector) ForestNumberOfTrees 

func (nc *NoopCollector) ForestNumberOfTrees(number uint64)

func (*NoopCollector) FulfilledHeight 

func (nc *NoopCollector) FulfilledHeight(blockHeight uint64)

func (*NoopCollector) HotStuffBusyDuration 

func (nc *NoopCollector) HotStuffBusyDuration(duration time.Duration, event string)

func (*NoopCollector) HotStuffIdleDuration 

func (nc *NoopCollector) HotStuffIdleDuration(duration time.Duration)

func (*NoopCollector) HotStuffWaitDuration 

func (nc *NoopCollector) HotStuffWaitDuration(duration time.Duration, event string)

func (*NoopCollector) InboundConnections 

func (nc *NoopCollector) InboundConnections(_ uint)

func (*NoopCollector) InboundMessageReceived 

func (nc *NoopCollector) InboundMessageReceived(int, string, string, string)

func (*NoopCollector) LatestTrieMaxDepthTouched 

func (nc *NoopCollector) LatestTrieMaxDepthTouched(maxDepth uint16)

func (*NoopCollector) LatestTrieRegCount 

func (nc *NoopCollector) LatestTrieRegCount(number uint64)

func (*NoopCollector) LatestTrieRegCountDiff 

func (nc *NoopCollector) LatestTrieRegCountDiff(number int64)

func (*NoopCollector) LatestTrieRegSize 

func (nc *NoopCollector) LatestTrieRegSize(size uint64)

func (*NoopCollector) LatestTrieRegSizeDiff 

func (nc *NoopCollector) LatestTrieRegSizeDiff(size int64)

func (*NoopCollector) MempoolEntries 

func (nc *NoopCollector) MempoolEntries(resource string, entries uint)

func (*NoopCollector) MessageAdded 

func (nc *NoopCollector) MessageAdded(priority int)

func (*NoopCollector) MessageHandled 

func (nc *NoopCollector) MessageHandled(engine string, message string)

func (*NoopCollector) MessageProcessingFinished 

func (nc *NoopCollector) MessageProcessingFinished(topic string, duration time.Duration)

func (*NoopCollector) MessageProcessingStarted 

func (nc *NoopCollector) MessageProcessingStarted(topic string)

func (*NoopCollector) MessageReceived 

func (nc *NoopCollector) MessageReceived(engine string, message string)

func (*NoopCollector) MessageRemoved 

func (nc *NoopCollector) MessageRemoved(priority int)

func (*NoopCollector) MessageSent 

func (nc *NoopCollector) MessageSent(engine string, message string)

func (*NoopCollector) MessagesReceived 

func (nc *NoopCollector) MessagesReceived(prefix string, n uint64)

func (*NoopCollector) NewConnectionEstablished 

func (nc *NoopCollector) NewConnectionEstablished()

func (*NoopCollector) NotificationSent 

func (nc *NoopCollector) NotificationSent(height uint64)

func (*NoopCollector) OnApprovalProcessingDuration 

func (nc *NoopCollector) OnApprovalProcessingDuration(duration time.Duration)

func (*NoopCollector) OnAssignedChunkProcessedAtAssigner 

func (nc *NoopCollector) OnAssignedChunkProcessedAtAssigner()

func (*NoopCollector) OnAssignedChunkReceivedAtFetcher 

func (nc *NoopCollector) OnAssignedChunkReceivedAtFetcher()

func (*NoopCollector) OnBlockConsumerJobDone 

func (nc *NoopCollector) OnBlockConsumerJobDone(uint64)

func (*NoopCollector) OnChunkConsumerJobDone 

func (nc *NoopCollector) OnChunkConsumerJobDone(uint64)

func (*NoopCollector) OnChunkDataPackArrivedAtFetcher 

func (nc *NoopCollector) OnChunkDataPackArrivedAtFetcher()

func (*NoopCollector) OnChunkDataPackRequestDispatchedInNetworkByRequester 

func (nc *NoopCollector) OnChunkDataPackRequestDispatchedInNetworkByRequester()

func (*NoopCollector) OnChunkDataPackRequestReceivedByRequester 

func (nc *NoopCollector) OnChunkDataPackRequestReceivedByRequester()

func (*NoopCollector) OnChunkDataPackRequestSentByFetcher 

func (nc *NoopCollector) OnChunkDataPackRequestSentByFetcher()

func (*NoopCollector) OnChunkDataPackResponseReceivedFromNetworkByRequester 

func (nc *NoopCollector) OnChunkDataPackResponseReceivedFromNetworkByRequester()

func (*NoopCollector) OnChunkDataPackSentToFetcher 

func (nc *NoopCollector) OnChunkDataPackSentToFetcher()

func (*NoopCollector) OnChunksAssignmentDoneAtAssigner 

func (nc *NoopCollector) OnChunksAssignmentDoneAtAssigner(chunks int)

func (*NoopCollector) OnDNSCacheHit 

func (nc *NoopCollector) OnDNSCacheHit()

func (*NoopCollector) OnDNSCacheInvalidated 

func (nc *NoopCollector) OnDNSCacheInvalidated()

func (*NoopCollector) OnDNSCacheMiss 

func (nc *NoopCollector) OnDNSCacheMiss()

func (*NoopCollector) OnDNSLookupRequestDropped 

func (nc *NoopCollector) OnDNSLookupRequestDropped()

func (*NoopCollector) OnEntityEjectionDueToEmergency 

func (nc *NoopCollector) OnEntityEjectionDueToEmergency()

func (*NoopCollector) OnEntityEjectionDueToFullCapacity 

func (nc *NoopCollector) OnEntityEjectionDueToFullCapacity()

func (*NoopCollector) OnExecutionResultReceivedAtAssignerEngine 

func (nc *NoopCollector) OnExecutionResultReceivedAtAssignerEngine()

func (*NoopCollector) OnFinalizedBlockArrivedAtAssigner 

func (nc *NoopCollector) OnFinalizedBlockArrivedAtAssigner(height uint64)

func (*NoopCollector) OnGraftReceived 

func (nc *NoopCollector) OnGraftReceived(int)

func (*NoopCollector) OnIHaveReceived 

func (nc *NoopCollector) OnIHaveReceived(int)

func (*NoopCollector) OnIWantReceived 

func (nc *NoopCollector) OnIWantReceived(int)

func (*NoopCollector) OnIncomingRpcAcceptedFully 

func (nc *NoopCollector) OnIncomingRpcAcceptedFully()

func (*NoopCollector) OnIncomingRpcAcceptedOnlyForControlMessages 

func (nc *NoopCollector) OnIncomingRpcAcceptedOnlyForControlMessages()

func (*NoopCollector) OnIncomingRpcRejected 

func (nc *NoopCollector) OnIncomingRpcRejected()

func (*NoopCollector) OnKeyGetFailure 

func (nc *NoopCollector) OnKeyGetFailure()

func (*NoopCollector) OnKeyGetSuccess 

func (nc *NoopCollector) OnKeyGetSuccess()

func (*NoopCollector) OnKeyPutAttempt 

func (nc *NoopCollector) OnKeyPutAttempt(uint32)

func (*NoopCollector) OnKeyPutDeduplicated 

func (nc *NoopCollector) OnKeyPutDeduplicated()

func (*NoopCollector) OnKeyPutDrop 

func (nc *NoopCollector) OnKeyPutDrop()

func (*NoopCollector) OnKeyPutSuccess 

func (nc *NoopCollector) OnKeyPutSuccess(uint32)

func (*NoopCollector) OnKeyRemoved 

func (nc *NoopCollector) OnKeyRemoved(uint32)

func (*NoopCollector) OnPruneReceived 

func (nc *NoopCollector) OnPruneReceived(int)

func (*NoopCollector) OnPublishedGossipMessagesReceived 

func (nc *NoopCollector) OnPublishedGossipMessagesReceived(count int)

func (*NoopCollector) OnRateLimitedUnicastMessage 

func (nc *NoopCollector) OnRateLimitedUnicastMessage(role, msgType, topic, reason string)

func (*NoopCollector) OnReceiptProcessingDuration 

func (nc *NoopCollector) OnReceiptProcessingDuration(duration time.Duration)

func (*NoopCollector) OnResultApprovalDispatchedInNetworkByVerifier 

func (nc *NoopCollector) OnResultApprovalDispatchedInNetworkByVerifier()

func (*NoopCollector) OnUnauthorizedMessage 

func (nc *NoopCollector) OnUnauthorizedMessage(role, msgType, topic, offense string)

func (*NoopCollector) OnVerifiableChunkReceivedAtVerifierEngine 

func (nc *NoopCollector) OnVerifiableChunkReceivedAtVerifierEngine()

func (*NoopCollector) OnVerifiableChunkSentToVerifier 

func (nc *NoopCollector) OnVerifiableChunkSentToVerifier()

func (*NoopCollector) OutboundConnections 

func (nc *NoopCollector) OutboundConnections(_ uint)

func (*NoopCollector) OutboundMessageSent 

func (nc *NoopCollector) OutboundMessageSent(int, string, string, string)

func (*NoopCollector) PayloadProductionDuration 

func (nc *NoopCollector) PayloadProductionDuration(duration time.Duration)

func (*NoopCollector) Peers 

func (nc *NoopCollector) Peers(prefix string, n int)

func (*NoopCollector) ProofSize 

func (nc *NoopCollector) ProofSize(bytes uint32)

func (*NoopCollector) Pruned 

func (nc *NoopCollector) Pruned(height uint64, duration time.Duration)

func (*NoopCollector) PrunedBlockByHeight 

func (nc *NoopCollector) PrunedBlockByHeight(status *chainsync.Status)

func (*NoopCollector) PrunedBlockById 

func (nc *NoopCollector) PrunedBlockById(status *chainsync.Status)

func (*NoopCollector) PrunedBlocks 

func (nc *NoopCollector) PrunedBlocks(totalByHeight, totalById, storedByHeight, storedById int)

func (*NoopCollector) QueueDuration 

func (nc *NoopCollector) QueueDuration(duration time.Duration, priority int)

func (*NoopCollector) RanGC 

func (nc *NoopCollector) RanGC(duration time.Duration)

func (*NoopCollector) RangeRequested 

func (nc *NoopCollector) RangeRequested(ran chainsync.Range)

func (*NoopCollector) ReadDuration 

func (nc *NoopCollector) ReadDuration(duration time.Duration)

func (*NoopCollector) ReadDurationPerItem 

func (nc *NoopCollector) ReadDurationPerItem(duration time.Duration)

func (*NoopCollector) ReadValuesNumber 

func (nc *NoopCollector) ReadValuesNumber(number uint64)

func (*NoopCollector) ReadValuesSize 

func (nc *NoopCollector) ReadValuesSize(byte uint64)

func (*NoopCollector) ReceiptSkipped 

func (nc *NoopCollector) ReceiptSkipped()

func (*NoopCollector) Register 

func (nc *NoopCollector) Register(resource string, entriesFunc module.EntriesFunc) error

func (*NoopCollector) RequestCanceled 

func (nc *NoopCollector) RequestCanceled()

func (*NoopCollector) RequestFailed 

func (nc *NoopCollector) RequestFailed(duration time.Duration, retryable bool)

func (*NoopCollector) RequestSucceeded 

func (nc *NoopCollector) RequestSucceeded(blockHeight uint64, duration time.Duration, totalSize uint64, numberOfAttempts int)

func (*NoopCollector) ResponseDropped 

func (nc *NoopCollector) ResponseDropped()

func (*NoopCollector) RootIDComputed 

func (nc *NoopCollector) RootIDComputed(duration time.Duration, numberOfChunks int)

func (*NoopCollector) RoutingTablePeerAdded 

func (nc *NoopCollector) RoutingTablePeerAdded()

func (*NoopCollector) RoutingTablePeerRemoved 

func (nc *NoopCollector) RoutingTablePeerRemoved()

func (*NoopCollector) RuntimeSetNumberOfAccounts 

func (nc *NoopCollector) RuntimeSetNumberOfAccounts(count uint64)

func (*NoopCollector) RuntimeTransactionChecked 

func (nc *NoopCollector) RuntimeTransactionChecked(dur time.Duration)

func (*NoopCollector) RuntimeTransactionInterpreted 

func (nc *NoopCollector) RuntimeTransactionInterpreted(dur time.Duration)

func (*NoopCollector) RuntimeTransactionParsed 

func (nc *NoopCollector) RuntimeTransactionParsed(dur time.Duration)

func (*NoopCollector) ScriptExecuted 

func (nc *NoopCollector) ScriptExecuted(dur time.Duration, size int)

func (*NoopCollector) SealedHeight 

func (nc *NoopCollector) SealedHeight(height uint64)

func (*NoopCollector) SetCurView 

func (nc *NoopCollector) SetCurView(view uint64)

func (*NoopCollector) SetMaxChunkDataPackAttemptsForNextUnsealedHeightAtRequester 

func (nc *NoopCollector) SetMaxChunkDataPackAttemptsForNextUnsealedHeightAtRequester(attempts uint64)

func (*NoopCollector) SetQCView 

func (nc *NoopCollector) SetQCView(view uint64)

func (*NoopCollector) SetTimeout 

func (nc *NoopCollector) SetTimeout(duration time.Duration)

func (*NoopCollector) SignerProcessingDuration 

func (nc *NoopCollector) SignerProcessingDuration(duration time.Duration)

func (*NoopCollector) StartBlockReceivedToExecuted 

func (nc *NoopCollector) StartBlockReceivedToExecuted(blockID flow.Identifier)

func (*NoopCollector) StartBlockToSeal 

func (nc *NoopCollector) StartBlockToSeal(blockID flow.Identifier)

func (*NoopCollector) StartCollectionToFinalized 

func (nc *NoopCollector) StartCollectionToFinalized(collectionID flow.Identifier)

func (*NoopCollector) TotalConnectionsInPool 

func (nc *NoopCollector) TotalConnectionsInPool(connectionCount uint, connectionPoolSize uint)

func (*NoopCollector) TransactionExecuted 

func (nc *NoopCollector) TransactionExecuted(txID flow.Identifier, when time.Time)

func (*NoopCollector) TransactionExpired 

func (nc *NoopCollector) TransactionExpired(txID flow.Identifier)

func (*NoopCollector) TransactionFinalized 

func (nc *NoopCollector) TransactionFinalized(txID flow.Identifier, when time.Time)

func (*NoopCollector) TransactionIngested 

func (nc *NoopCollector) TransactionIngested(txID flow.Identifier)

func (*NoopCollector) TransactionReceived 

func (nc *NoopCollector) TransactionReceived(txID flow.Identifier, when time.Time)

func (*NoopCollector) TransactionResultFetched 

func (nc *NoopCollector) TransactionResultFetched(dur time.Duration, size int)

func (*NoopCollector) TransactionSubmissionFailed 

func (nc *NoopCollector) TransactionSubmissionFailed()

func (*NoopCollector) UnicastMessageSendingCompleted 

func (nc *NoopCollector) UnicastMessageSendingCompleted(topic string)

func (*NoopCollector) UnicastMessageSendingStarted 

func (nc *NoopCollector) UnicastMessageSendingStarted(topic string)

func (*NoopCollector) UnstakedInboundConnections 

func (nc *NoopCollector) UnstakedInboundConnections(_ uint)

func (*NoopCollector) UnstakedOutboundConnections 

func (nc *NoopCollector) UnstakedOutboundConnections(_ uint)

func (*NoopCollector) UpdateCollectionMaxHeight 

func (nc *NoopCollector) UpdateCollectionMaxHeight(height uint64)

func (*NoopCollector) UpdateCount 

func (nc *NoopCollector) UpdateCount()

func (*NoopCollector) UpdateDuration 

func (nc *NoopCollector) UpdateDuration(duration time.Duration)

func (*NoopCollector) UpdateDurationPerItem 

func (nc *NoopCollector) UpdateDurationPerItem(duration time.Duration)

func (*NoopCollector) UpdateExecutionReceiptMaxHeight 

func (nc *NoopCollector) UpdateExecutionReceiptMaxHeight(height uint64)

func (*NoopCollector) UpdateValuesNumber 

func (nc *NoopCollector) UpdateValuesNumber(number uint64)

func (*NoopCollector) UpdateValuesSize 

func (nc *NoopCollector) UpdateValuesSize(byte uint64)

func (*NoopCollector) ValidatorProcessingDuration 

func (nc *NoopCollector) ValidatorProcessingDuration(duration time.Duration)

func (*NoopCollector) Wantlist 

func (nc *NoopCollector) Wantlist(prefix string, n int)

type ObserverCollector 

type ObserverCollector struct {
	// contains filtered or unexported fields
}

func NewObserverCollector 

func NewObserverCollector() *ObserverCollector

func (*ObserverCollector) RecordRPC 

func (oc *ObserverCollector) RecordRPC(handler, rpc string, code codes.Code)

type PingCollector 

type PingCollector struct {
	// contains filtered or unexported fields
}

func NewPingCollector 

func NewPingCollector() *PingCollector

func (*PingCollector) NodeInfo 

func (pc *PingCollector) NodeInfo(node *flow.Identity, nodeInfo string, version string, sealedHeight uint64, hotstuffCurView uint64)

func (*PingCollector) NodeReachable 

func (pc *PingCollector) NodeReachable(node *flow.Identity, nodeInfo string, rtt time.Duration)

type RateLimitedBlockstoreCollector 

type RateLimitedBlockstoreCollector struct {
	// contains filtered or unexported fields
}

func (*RateLimitedBlockstoreCollector) BytesRead 

func (r *RateLimitedBlockstoreCollector) BytesRead(n int)

type Server 

type Server struct {
	// contains filtered or unexported fields
}

Server is the http server that will be serving the /metrics request for prometheus

func NewServer 

func NewServer(log zerolog.Logger, port uint) *Server

NewServer creates a new server that will start on the specified port, and responds to only the `/metrics` endpoint

func (*Server) Done 

func (m *Server) Done() <-chan struct{}

Done returns a channel that will close when shutdown is complete.

func (*Server) Ready 

func (m *Server) Ready() <-chan struct{}

Ready returns a channel that will close when the network stack is ready.

type StorageCollector 

type StorageCollector struct {
	// contains filtered or unexported fields
}

func GetStorageCollector 

func GetStorageCollector() *StorageCollector

func (*StorageCollector) RetryOnConflict 

func (sc *StorageCollector) RetryOnConflict()

func (*StorageCollector) SkipDuplicate 

func (sc *StorageCollector) SkipDuplicate()

type TransactionCollector 

type TransactionCollector struct {
	// contains filtered or unexported fields
}

func NewTransactionCollector 

func NewTransactionCollector(transactionTimings mempool.TransactionTimings, log zerolog.Logger,
	logTimeToFinalized bool, logTimeToExecuted bool, logTimeToFinalizedExecuted bool) *TransactionCollector

func (*TransactionCollector) ScriptExecuted 

func (tc *TransactionCollector) ScriptExecuted(dur time.Duration, size int)

func (*TransactionCollector) TransactionExecuted 

func (tc *TransactionCollector) TransactionExecuted(txID flow.Identifier, when time.Time)

func (*TransactionCollector) TransactionExpired 

func (tc *TransactionCollector) TransactionExpired(txID flow.Identifier)

func (*TransactionCollector) TransactionFinalized 

func (tc *TransactionCollector) TransactionFinalized(txID flow.Identifier, when time.Time)

func (*TransactionCollector) TransactionReceived 

func (tc *TransactionCollector) TransactionReceived(txID flow.Identifier, when time.Time)

func (*TransactionCollector) TransactionResultFetched 

func (tc *TransactionCollector) TransactionResultFetched(dur time.Duration, size int)

func (*TransactionCollector) TransactionSubmissionFailed 

func (tc *TransactionCollector) TransactionSubmissionFailed()

func (*TransactionCollector) UpdateExecutionReceiptMaxHeight 

func (tc *TransactionCollector) UpdateExecutionReceiptMaxHeight(height uint64)

type VerificationCollector 

type VerificationCollector struct {
	// contains filtered or unexported fields
}

func NewVerificationCollector 

func NewVerificationCollector(tracer module.Tracer, registerer prometheus.Registerer) *VerificationCollector

func (*VerificationCollector) OnAssignedChunkProcessedAtAssigner 

func (vc *VerificationCollector) OnAssignedChunkProcessedAtAssigner()

OnAssignedChunkProcessedAtAssigner increments a counter that keeps track of the total number of assigned chunks pushed by assigner engine to the fetcher engine.

func (*VerificationCollector) OnAssignedChunkReceivedAtFetcher 

func (vc *VerificationCollector) OnAssignedChunkReceivedAtFetcher()

OnAssignedChunkReceivedAtFetcher increments a counter that keeps track of number of assigned chunks arrive at fetcher engine.

func (*VerificationCollector) OnBlockConsumerJobDone 

func (vc *VerificationCollector) OnBlockConsumerJobDone(processedIndex uint64)

OnBlockConsumerJobDone is invoked by block consumer whenever it is notified a job is done by a worker. It sets the last processed block job index.

func (*VerificationCollector) OnChunkConsumerJobDone 

func (vc *VerificationCollector) OnChunkConsumerJobDone(processedIndex uint64)

OnChunkConsumerJobDone is invoked by chunk consumer whenever it is notified a job is done by a worker. It sets the last processed chunk job index.

func (*VerificationCollector) OnChunkDataPackArrivedAtFetcher 

func (vc *VerificationCollector) OnChunkDataPackArrivedAtFetcher()

OnChunkDataPackArrivedAtFetcher increments a counter that keeps track of number of chunk data packs arrived at fetcher engine from requester engine.

func (*VerificationCollector) OnChunkDataPackRequestDispatchedInNetworkByRequester 

func (vc *VerificationCollector) OnChunkDataPackRequestDispatchedInNetworkByRequester()

OnChunkDataPackRequestDispatchedInNetworkByRequester increments a counter that keeps track of number of chunk data pack requests that the requester engine dispatches in the network (to the execution nodes).

func (*VerificationCollector) OnChunkDataPackRequestReceivedByRequester 

func (vc *VerificationCollector) OnChunkDataPackRequestReceivedByRequester()

OnChunkDataPackRequestReceivedByRequester increments a counter that keeps track of number of chunk data pack requests arrive at the requester engine from the fetcher engine.

func (*VerificationCollector) OnChunkDataPackRequestSentByFetcher 

func (vc *VerificationCollector) OnChunkDataPackRequestSentByFetcher()

OnChunkDataPackRequestSentByFetcher increments a counter that keeps track of number of chunk data pack requests that fetcher engine sends to requester engine.

func (*VerificationCollector) OnChunkDataPackResponseReceivedFromNetworkByRequester 

func (vc *VerificationCollector) OnChunkDataPackResponseReceivedFromNetworkByRequester()

OnChunkDataPackResponseReceivedFromNetworkByRequester increments a counter that keeps track of number of chunk data pack responses that the requester engine receives from execution nodes (through network).

func (*VerificationCollector) OnChunkDataPackSentToFetcher 

func (vc *VerificationCollector) OnChunkDataPackSentToFetcher()

OnChunkDataPackSentToFetcher increases a counter that keeps track of number of chunk data packs sent to the fetcher engine from requester engine.

func (*VerificationCollector) OnChunksAssignmentDoneAtAssigner 

func (vc *VerificationCollector) OnChunksAssignmentDoneAtAssigner(chunks int)

OnChunksAssignmentDoneAtAssigner increments a counter that keeps track of the total number of assigned chunks to the verification node.

func (*VerificationCollector) OnExecutionResultReceivedAtAssignerEngine 

func (vc *VerificationCollector) OnExecutionResultReceivedAtAssignerEngine()

OnExecutionResultReceivedAtAssignerEngine is called whenever a new execution result arrives at Assigner engine. It increments total number of received results.

func (*VerificationCollector) OnFinalizedBlockArrivedAtAssigner 

func (vc *VerificationCollector) OnFinalizedBlockArrivedAtAssigner(height uint64)

OnFinalizedBlockArrivedAtAssigner sets a gauge that keeps track of number of the latest block height arrives at assigner engine. Note that it assumes blocks are coming to assigner engine in strictly increasing order of their height.

func (*VerificationCollector) OnResultApprovalDispatchedInNetworkByVerifier 

func (vc *VerificationCollector) OnResultApprovalDispatchedInNetworkByVerifier()

OnResultApprovalDispatchedInNetwork is called whenever a result approval for is emitted to consensus nodes. It increases the total number of result approvals.

func (*VerificationCollector) OnVerifiableChunkReceivedAtVerifierEngine 

func (vc *VerificationCollector) OnVerifiableChunkReceivedAtVerifierEngine()

OnVerifiableChunkReceivedAtVerifierEngine is called whenever a verifiable chunk is received by Verifier engine from Assigner engine.It increments the total number of sent verifiable chunks.

func (*VerificationCollector) OnVerifiableChunkSentToVerifier 

func (vc *VerificationCollector) OnVerifiableChunkSentToVerifier()

OnVerifiableChunkSentToVerifier increments a counter that keeps track of number of verifiable chunks fetcher engine sent to verifier engine.

func (*VerificationCollector) SetMaxChunkDataPackAttemptsForNextUnsealedHeightAtRequester 

func (vc *VerificationCollector) SetMaxChunkDataPackAttemptsForNextUnsealedHeightAtRequester(attempts uint64)

SetMaxChunkDataPackAttemptsForNextUnsealedHeightAtRequester is invoked when a cycle of requesting chunk data packs is done by requester engine. It updates the maximum number of attempts made by requester engine for requesting the chunk data packs of the next unsealed height. The maximum is taken over the history of all chunk data packs requested during that cycle that belong to the next unsealed height.

Source Files

View all Source files

Directories

Path Synopsis
collection
consensus
execution
verification

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.