metrics

package
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Aug 15, 2021 License: Apache-2.0, MIT Imports: 22 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// common
	Version, _     = tag.NewKey("version")
	Commit, _      = tag.NewKey("commit")
	NodeType, _    = tag.NewKey("node_type")
	PeerID, _      = tag.NewKey("peer_id")
	MinerID, _     = tag.NewKey("miner_id")
	Coinbase, _    = tag.NewKey("coinbase")
	FailureType, _ = tag.NewKey("failure_type")

	// chain
	Local, _        = tag.NewKey("local")
	MessageFrom, _  = tag.NewKey("message_from")
	MessageTo, _    = tag.NewKey("message_to")
	MessageNonce, _ = tag.NewKey("message_nonce")
	ReceivedFrom, _ = tag.NewKey("received_from")
	Endpoint, _     = tag.NewKey("endpoint")
	APIInterface, _ = tag.NewKey("api") // to distinguish between gateway api and full node api endpoint calls

	Type, _ = tag.NewKey("type")
	// miner
	TaskType, _       = tag.NewKey("task_type")
	WorkerHostname, _ = tag.NewKey("worker_hostname")
)

Global Tags

View Source 
var (
	// common
	EpikInfo           = stats.Int64("info", "Arbitrary counter to tag epik info to", stats.UnitDimensionless)
	PeerCount          = stats.Int64("peer/count", "Current number of EpiK peers", stats.UnitDimensionless)
	APIRequestDuration = stats.Float64("api/request_duration_ms", "Duration of API requests", stats.UnitMilliseconds)

	// chain
	ChainNodeHeight                     = stats.Int64("chain/node_height", "Current Height of the node", stats.UnitDimensionless)
	ChainNodeHeightExpected             = stats.Int64("chain/node_height_expected", "Expected Height of the node", stats.UnitDimensionless)
	ChainNodeWorkerHeight               = stats.Int64("chain/node_worker_height", "Current Height of workers on the node", stats.UnitDimensionless)
	MessagePublished                    = stats.Int64("message/published", "Counter for total locally published messages", stats.UnitDimensionless)
	MessageReceived                     = stats.Int64("message/received", "Counter for total received messages", stats.UnitDimensionless)
	MessageValidationFailure            = stats.Int64("message/failure", "Counter for message validation failures", stats.UnitDimensionless)
	MessageValidationSuccess            = stats.Int64("message/success", "Counter for message validation successes", stats.UnitDimensionless)
	BlockPublished                      = stats.Int64("block/published", "Counter for total locally published blocks", stats.UnitDimensionless)
	BlockReceived                       = stats.Int64("block/received", "Counter for total received blocks", stats.UnitDimensionless)
	BlockValidationFailure              = stats.Int64("block/failure", "Counter for block validation failures", stats.UnitDimensionless)
	BlockValidationSuccess              = stats.Int64("block/success", "Counter for block validation successes", stats.UnitDimensionless)
	BlockValidationDurationMilliseconds = stats.Float64("block/validation_ms", "Duration for Block Validation in ms", stats.UnitMilliseconds)
	BlockDelay                          = stats.Int64("block/delay", "Delay of accepted blocks, where delay is >5s", stats.UnitMilliseconds)
	PubsubPublishMessage                = stats.Int64("pubsub/published", "Counter for total published messages", stats.UnitDimensionless)
	PubsubDeliverMessage                = stats.Int64("pubsub/delivered", "Counter for total delivered messages", stats.UnitDimensionless)
	PubsubRejectMessage                 = stats.Int64("pubsub/rejected", "Counter for total rejected messages", stats.UnitDimensionless)
	PubsubDuplicateMessage              = stats.Int64("pubsub/duplicate", "Counter for total duplicate messages", stats.UnitDimensionless)
	PubsubRecvRPC                       = stats.Int64("pubsub/recv_rpc", "Counter for total received RPCs", stats.UnitDimensionless)
	PubsubSendRPC                       = stats.Int64("pubsub/send_rpc", "Counter for total sent RPCs", stats.UnitDimensionless)
	PubsubDropRPC                       = stats.Int64("pubsub/drop_rpc", "Counter for total dropped RPCs", stats.UnitDimensionless)
	VMFlushCopyDuration                 = stats.Float64("vm/flush_copy_ms", "Time spent in VM Flush Copy", stats.UnitMilliseconds)
	VMFlushCopyCount                    = stats.Int64("vm/flush_copy_count", "Number of copied objects", stats.UnitDimensionless)

	MessageReceivedBytes    = stats.Int64("message/received_bytes", "Counter for total bytes of received messages", stats.UnitBytes)
	BlockReceivedBytes      = stats.Int64("block/received_bytes", "Counter for total bytes of received blocks", stats.UnitBytes)
	ServeSyncSuccess        = stats.Int64("serve/sync_success", "Counter for successes", stats.UnitDimensionless)
	ServeSyncFailure        = stats.Int64("serve/sync_failure", "Counter for failures", stats.UnitDimensionless)
	ServeSyncBytes          = stats.Int64("serve/sync_bytes", "Counter for total sent bytes", stats.UnitBytes)
	TipsetMessagesCount     = stats.Int64("tipset/messages_count", "Counter of messages in tipsets", stats.UnitDimensionless)
	TipsetMessagesRate      = stats.Float64("tipset/messages_rate", "Counter of processed messages per second", stats.UnitDimensionless)
	TipsetPublishDealsCount = stats.Int64("tipset/publishdeals_count", "Counter of publishdeals in tipsets", stats.UnitDimensionless)
	TipsetSubmitPoStsCount  = stats.Int64("tipset/submitposts_count", "Counter of submitposts in tipsets", stats.UnitDimensionless)
	TipsetGasUsed           = stats.Int64("tipset/gasused", "Counter of gas in one tipset", stats.UnitDimensionless)

	// Sys
	BandwidthTotal = stats.Int64("bandwidth/total", "Counter for total traffic bytes", stats.UnitBytes)
	BandwidthRate  = stats.Float64("bandwidth/rate", "Counter for bytes per second", stats.UnitBytes)
	SysCpuUsed     = stats.Int64("sys/cpu_used", "Counter for used percentage of cpu used", stats.UnitDimensionless)
	SysMemUsed     = stats.Int64("sys/mem_used", "Counter for used percentage of ram used", stats.UnitDimensionless)
	SysDiskUsed    = stats.Int64("sys/disk_used", "Counter for used percentage of disk", stats.UnitDimensionless)

	// miner
	WorkerCallsStarted           = stats.Int64("sealing/worker_calls_started", "Counter of started worker tasks", stats.UnitDimensionless)
	WorkerCallsReturnedCount     = stats.Int64("sealing/worker_calls_returned_count", "Counter of returned worker tasks", stats.UnitDimensionless)
	WorkerCallsReturnedDuration  = stats.Float64("sealing/worker_calls_returned_ms", "Counter of returned worker tasks", stats.UnitMilliseconds)
	WorkerUntrackedCallsReturned = stats.Int64("sealing/worker_untracked_calls_returned", "Counter of returned untracked worker tasks", stats.UnitDimensionless)

	ServeTransferBytes  = stats.Int64("serve/transfer_bytes", "Counter for total sent bytes", stats.UnitBytes)
	ServeTransferAccept = stats.Int64("serve/transfer_accept", "Counter for total accepted requests", stats.UnitDimensionless)
	ServeTransferResult = stats.Int64("serve/transfer_result", "Counter for process results", stats.UnitDimensionless)
	CoinbaseBalance     = stats.Float64("coinbase/balance", "Counter for coinbase balance in EPK", stats.UnitDimensionless)
	MinerPower          = stats.Int64("miner/power", "miner power", stats.UnitBytes)
	MinerSectorCount    = stats.Int64("miner/sector", "Counter for miner sector with type", stats.UnitDimensionless)

	// splitstore
	SplitstoreMiss                  = stats.Int64("splitstore/miss", "Number of misses in hotstre access", stats.UnitDimensionless)
	SplitstoreCompactionTimeSeconds = stats.Float64("splitstore/compaction_time", "Compaction time in seconds", stats.UnitSeconds)
	SplitstoreCompactionHot         = stats.Int64("splitstore/hot", "Number of hot blocks in last compaction", stats.UnitDimensionless)
	SplitstoreCompactionCold        = stats.Int64("splitstore/cold", "Number of cold blocks in last compaction", stats.UnitDimensionless)
	SplitstoreCompactionDead        = stats.Int64("splitstore/dead", "Number of dead blocks in last compaction", stats.UnitDimensionless)

	// mpool
	MpoolPendingCount = stats.Int64("mpool/pending_count", "Counter of pending messages in mpool", stats.UnitDimensionless)
)

Measures

View Source 
var (
	InfoView = &view.View{
		Name:        "info",
		Description: "epik node information",
		Measure:     EpikInfo,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{Version, Commit},
	}
	ChainNodeHeightView = &view.View{
		Measure:     ChainNodeHeight,
		Aggregation: view.LastValue(),
	}
	ChainNodeHeightExpectedView = &view.View{
		Measure:     ChainNodeHeightExpected,
		Aggregation: view.LastValue(),
	}
	ChainNodeWorkerHeightView = &view.View{
		Measure:     ChainNodeWorkerHeight,
		Aggregation: view.LastValue(),
	}
	BlockReceivedView = &view.View{
		Measure:     BlockReceived,
		Aggregation: view.Count(),
	}
	BlockValidationFailureView = &view.View{
		Measure:     BlockValidationFailure,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{FailureType},
	}
	BlockValidationSuccessView = &view.View{
		Measure:     BlockValidationSuccess,
		Aggregation: view.Count(),
	}
	BlockValidationDurationView = &view.View{
		Measure:     BlockValidationDurationMilliseconds,
		Aggregation: defaultMillisecondsDistribution,
	}
	BlockDelayView = &view.View{
		Measure: BlockDelay,
		TagKeys: []tag.Key{MinerID},
		Aggregation: func() *view.Aggregation {
			var bounds []float64
			for i := 5; i < 29; i++ {
				bounds = append(bounds, float64(i*1000))
			}
			for i := 30; i < 60; i += 2 {
				bounds = append(bounds, float64(i*1000))
			}
			for i := 60; i <= 300; i += 10 {
				bounds = append(bounds, float64(i*1000))
			}
			bounds = append(bounds, 600*1000)
			return view.Distribution(bounds...)
		}(),
	}
	MessagePublishedView = &view.View{
		Measure:     MessagePublished,
		Aggregation: view.Count(),
	}
	MessageReceivedView = &view.View{
		Measure:     MessageReceived,
		Aggregation: view.Count(),
	}
	MessageValidationFailureView = &view.View{
		Measure:     MessageValidationFailure,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{FailureType, Local},
	}
	MessageValidationSuccessView = &view.View{
		Measure:     MessageValidationSuccess,
		Aggregation: view.Count(),
	}
	PeerCountView = &view.View{
		Measure:     PeerCount,
		Aggregation: view.LastValue(),
	}
	PubsubPublishMessageView = &view.View{
		Measure:     PubsubPublishMessage,
		Aggregation: view.Count(),
	}
	PubsubDeliverMessageView = &view.View{
		Measure:     PubsubDeliverMessage,
		Aggregation: view.Count(),
	}
	PubsubRejectMessageView = &view.View{
		Measure:     PubsubRejectMessage,
		Aggregation: view.Count(),
	}
	PubsubDuplicateMessageView = &view.View{
		Measure:     PubsubDuplicateMessage,
		Aggregation: view.Count(),
	}
	PubsubRecvRPCView = &view.View{
		Measure:     PubsubRecvRPC,
		Aggregation: view.Count(),
	}
	PubsubSendRPCView = &view.View{
		Measure:     PubsubSendRPC,
		Aggregation: view.Count(),
	}
	PubsubDropRPCView = &view.View{
		Measure:     PubsubDropRPC,
		Aggregation: view.Count(),
	}
	APIRequestDurationView = &view.View{
		Measure:     APIRequestDuration,
		Aggregation: defaultMillisecondsDistribution,
		TagKeys:     []tag.Key{APIInterface, Endpoint},
	}
	VMFlushCopyDurationView = &view.View{
		Measure:     VMFlushCopyDuration,
		Aggregation: view.Sum(),
	}
	VMFlushCopyCountView = &view.View{
		Measure:     VMFlushCopyCount,
		Aggregation: view.Sum(),
	}

	MessageReceivedBytesView = &view.View{
		Measure:     MessageReceivedBytes,
		Aggregation: view.Sum(),
	}
	BlockReceivedBytesView = &view.View{
		Measure:     BlockReceivedBytes,
		Aggregation: view.Sum(),
	}
	ServeSyncSuccessView = &view.View{
		Measure:     ServeSyncSuccess,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{Type},
	}
	ServeSyncFailureView = &view.View{
		Measure:     ServeSyncFailure,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{FailureType},
	}
	ServeSyncBytesView = &view.View{
		Measure:     ServeSyncBytes,
		Aggregation: view.Sum(),
		TagKeys:     []tag.Key{Type},
	}
	TipsetMessagesCountView = &view.View{
		Measure:     TipsetMessagesCount,
		Aggregation: view.LastValue(),
	}
	TipsetMessagesRateView = &view.View{
		Measure:     TipsetMessagesRate,
		Aggregation: view.LastValue(),
	}
	TipsetPublishDealsCountView = &view.View{
		Measure:     TipsetPublishDealsCount,
		Aggregation: view.LastValue(),
	}
	TipsetSubmitPoStsCountView = &view.View{
		Measure:     TipsetSubmitPoStsCount,
		Aggregation: view.LastValue(),
	}
	TipsetGasUsedView = &view.View{
		Measure:     TipsetGasUsed,
		Aggregation: view.LastValue(),
	}

	// default
	BandwidthTotalView = &view.View{
		Measure:     BandwidthTotal,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{Type, NodeType},
	}
	BandwidthRateView = &view.View{
		Measure:     BandwidthRate,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{Type, NodeType},
	}
	SysCpuUsedView = &view.View{
		Measure:     SysCpuUsed,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{NodeType},
	}
	SysMemUsedView = &view.View{
		Measure:     SysMemUsed,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{NodeType},
	}
	SysDiskUsedView = &view.View{
		Measure:     SysDiskUsed,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{NodeType},
	}

	// miner
	WorkerCallsStartedView = &view.View{
		Measure:     WorkerCallsStarted,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{TaskType, WorkerHostname},
	}
	WorkerCallsReturnedCountView = &view.View{
		Measure:     WorkerCallsReturnedCount,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{TaskType, WorkerHostname},
	}
	WorkerUntrackedCallsReturnedView = &view.View{
		Measure:     WorkerUntrackedCallsReturned,
		Aggregation: view.Count(),
	}
	WorkerCallsReturnedDurationView = &view.View{
		Measure:     WorkerCallsReturnedDuration,
		Aggregation: workMillisecondsDistribution,
		TagKeys:     []tag.Key{TaskType, WorkerHostname},
	}

	ServeTransferBytesView = &view.View{
		Measure:     ServeTransferBytes,
		Aggregation: view.Sum(),
		TagKeys:     []tag.Key{Type},
	}
	ServeTransferAcceptView = &view.View{
		Measure:     ServeTransferAccept,
		Aggregation: view.Count(),
	}
	ServeTransferResultView = &view.View{
		Measure:     ServeTransferResult,
		Aggregation: view.Count(),
		TagKeys:     []tag.Key{Type},
	}
	CoinbaseBalanceView = &view.View{
		Measure:     CoinbaseBalance,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{Type, Coinbase},
	}
	MinerPowerView = &view.View{
		Measure:     MinerPower,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{Type, MinerID},
	}
	MinerSectorView = &view.View{
		Measure:     MinerSectorCount,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{Type, MinerID},
	}

	// splitstore
	SplitstoreMissView = &view.View{
		Measure:     SplitstoreMiss,
		Aggregation: view.Count(),
	}
	SplitstoreCompactionTimeSecondsView = &view.View{
		Measure:     SplitstoreCompactionTimeSeconds,
		Aggregation: view.LastValue(),
	}
	SplitstoreCompactionHotView = &view.View{
		Measure:     SplitstoreCompactionHot,
		Aggregation: view.LastValue(),
	}
	SplitstoreCompactionColdView = &view.View{
		Measure:     SplitstoreCompactionCold,
		Aggregation: view.Sum(),
	}
	SplitstoreCompactionDeadView = &view.View{
		Measure:     SplitstoreCompactionDead,
		Aggregation: view.Sum(),
	}
	MpoolPendingCountView = &view.View{
		Measure:     MpoolPendingCount,
		Aggregation: view.LastValue(),
	}
)
View Source 
var ChainNodeViews = append([]*view.View{
	ChainNodeHeightView,
	ChainNodeHeightExpectedView,
	ChainNodeWorkerHeightView,
	BlockReceivedView,
	BlockValidationFailureView,
	BlockValidationSuccessView,
	BlockValidationDurationView,
	BlockDelayView,
	MessagePublishedView,
	MessageReceivedView,
	MessageValidationFailureView,
	MessageValidationSuccessView,
	PubsubPublishMessageView,
	PubsubDeliverMessageView,
	PubsubRejectMessageView,
	PubsubDuplicateMessageView,
	PubsubRecvRPCView,
	PubsubSendRPCView,
	PubsubDropRPCView,
	VMFlushCopyCountView,
	VMFlushCopyDurationView,
	SplitstoreMissView,
	SplitstoreCompactionTimeSecondsView,
	SplitstoreCompactionHotView,
	SplitstoreCompactionColdView,
	SplitstoreCompactionDeadView,

	MpoolPendingCountView,

	MessageReceivedBytesView,
	BlockReceivedBytesView,
	ServeSyncSuccessView,
	ServeSyncFailureView,
	ServeSyncBytesView,
	TipsetMessagesCountView,
	TipsetMessagesRateView,
	TipsetPublishDealsCountView,
	TipsetSubmitPoStsCountView,
	TipsetGasUsedView,
}, DefaultViews...)
View Source 
var DefaultViews = func() []*view.View {
	views := []*view.View{
		InfoView,
		PeerCountView,
		APIRequestDurationView,

		BandwidthTotalView,
		BandwidthRateView,
		SysCpuUsedView,
		SysMemUsedView,
		SysDiskUsedView,
	}
	views = append(views, blockstore.DefaultViews...)
	views = append(views, rpcmetrics.DefaultViews...)
	return views
}()

DefaultViews is an array of OpenCensus views for metric gathering purposes

View Source 
var MinerNodeViews = append([]*view.View{
	WorkerCallsStartedView,
	WorkerCallsReturnedCountView,
	WorkerUntrackedCallsReturnedView,
	WorkerCallsReturnedDurationView,

	CoinbaseBalanceView,
	MinerPowerView,
	MinerSectorView,
	ServeTransferBytesView,
	ServeTransferAcceptView,
	ServeTransferResultView,
}, DefaultViews...)

Functions

func Exporter 

func Exporter() http.Handler

func MetricedFullAPI 

func MetricedFullAPI(a api.FullNode) api.FullNode

func MetricedGatewayAPI 

func MetricedGatewayAPI(a api.GatewayAPI) api.GatewayAPI

func MetricedStorMinerAPI 

func MetricedStorMinerAPI(a api.StorageMiner) api.StorageMiner

func MetricedWalletAPI 

func MetricedWalletAPI(a api.WalletAPI) api.WalletAPI

func MetricedWorkerAPI 

func MetricedWorkerAPI(a api.WorkerAPI) api.WorkerAPI

func RunSysInspector 

func RunSysInspector(ctx context.Context, reporter p2pmetrics.Reporter, interval time.Duration, nodeType string)

func SinceInMilliseconds 

func SinceInMilliseconds(startTime time.Time) float64

SinceInMilliseconds returns the duration of time since the provide time as a float64.

func SinceInSeconds 

func SinceInSeconds(startTime time.Time) float64

func Timer 

func Timer(ctx context.Context, m *stats.Float64Measure) func()

Timer is a function stopwatch, calling it starts the timer, calling the returned function will record the duration.

Types

type CountReader 

type CountReader struct {
	io.Reader
	// contains filtered or unexported fields
}

func NewCountReader 

func NewCountReader(r io.Reader) *CountReader

func (*CountReader) Count 

func (r *CountReader) Count() int64

func (*CountReader) Read 

func (r *CountReader) Read(buf []byte) (int, error)

type CountWriter 

type CountWriter struct {
	io.Writer
	// contains filtered or unexported fields
}

func NewCountWriter 

func NewCountWriter(w io.Writer) *CountWriter

func (*CountWriter) Count 

func (w *CountWriter) Count() int64

func (*CountWriter) Write 

func (w *CountWriter) Write(buf []byte) (int, error)

Source Files

View all Source files

Directories

Path Synopsis

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.