metrics

package
v0.3.1 Latest Latest
Warning

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

 Go to latest Published: Apr 21, 2024 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (

	// TableCacheStatistics represents table reader cache statistics.
	TableCacheStatistics = struct {
		Evict                *linmetric.BoundCounter // evict reader from cache
		Hit                  *linmetric.BoundCounter // get reader hit cache
		Miss                 *linmetric.BoundCounter // get reader miss cache
		Close                *linmetric.BoundCounter // close reader success
		CloseFailures        *linmetric.BoundCounter // close reader failure
		CreateReaderFailures *linmetric.BoundCounter // create read failure
		ActiveReaders        *linmetric.BoundGauge   // number of active reader in cache
	}{
		Evict:         tableCacheScope.NewCounter("evicts"),
		Hit:           tableCacheScope.NewCounter("cache_hits"),
		Miss:          tableCacheScope.NewCounter("cache_misses"),
		Close:         tableCacheScope.NewCounter("closes"),
		CloseFailures: tableCacheScope.NewCounter("close_failures"),
		ActiveReaders: tableCacheScope.NewGauge("active_readers"),
	}

	// TableWriteStatistics represents table file write statistics.
	TableWriteStatistics = struct {
		AddBadKeys *linmetric.BoundCounter // add bad key count
		AddKeys    *linmetric.BoundCounter // add key success
		WriteBytes *linmetric.BoundCounter // write data bytes
	}{
		AddBadKeys: tableWriteScope.NewCounter("bad_keys"),
		AddKeys:    tableWriteScope.NewCounter("add_keys"),
		WriteBytes: tableWriteScope.NewCounter("write_bytes"),
	}

	// TableReadStatistics represents table file read statistics.
	TableReadStatistics = struct {
		Gets           *linmetric.BoundCounter // get data by key success
		GetFailures    *linmetric.BoundCounter // get data by key failure
		ReadBytes      *linmetric.BoundCounter // bytes of read data
		MMaps          *linmetric.BoundCounter // map file success
		MMapFailures   *linmetric.BoundCounter // map file failure
		UnMMaps        *linmetric.BoundCounter // unmap file success
		UnMMapFailures *linmetric.BoundCounter // unmap file failures
	}{
		Gets:           tableReadScope.NewCounter("gets"),
		GetFailures:    tableReadScope.NewCounter("get_failures"),
		ReadBytes:      tableReadScope.NewCounter("read_bytes"),
		MMaps:          tableReadScope.NewCounter("mmaps"),
		MMapFailures:   tableReadScope.NewCounter("mmap_failures"),
		UnMMaps:        tableReadScope.NewCounter("unmmaps"),
		UnMMapFailures: tableReadScope.NewCounter("unmmap_failures"),
	}

	// CompactStatistics represents compact job statistics.
	CompactStatistics = struct {
		Compacting *linmetric.GaugeVec          // number of compacting jobs
		Failure    *linmetric.DeltaCounterVec   // compact failure
		Duration   *linmetric.DeltaHistogramVec // compact duration(include count)
	}{
		Compacting: flushScope.NewGaugeVec("compacting", "type"),
		Failure:    flushScope.NewCounterVec("failure", "type"),
		Duration:   compactScope.Scope("duration").NewHistogramVec("type"),
	}

	// FlushStatistics represents flush job statistics.
	FlushStatistics = struct {
		Flushing *linmetric.BoundGauge     // number of flushing jobs
		Failure  *linmetric.BoundCounter   // flush job failure
		Duration *linmetric.BoundHistogram // flush duration(include count)
	}{
		Flushing: flushScope.NewGauge("flushing"),
		Failure:  flushScope.NewCounter("failure"),
		Duration: flushScope.Scope("duration").NewHistogram(),
	}
)
View Source 
var (

	// FlushCheckerStatistics represents flush checker statistics.
	FlushCheckerStatistics = struct {
		FlushInFlight *linmetric.GaugeVec // number of family flushing
	}{
		FlushInFlight: shardScope.NewGaugeVec("flush_inflight", "db", "shard"),
	}
)

Functions

This section is empty.

Types

type BrokerDatabaseWriteStatistics 

type BrokerDatabaseWriteStatistics struct {
	OutOfTimeRange *linmetric.BoundCounter // timestamp of metrics out of acceptable write time range
	ShardNotFound  *linmetric.BoundCounter // shard not found count
}

BrokerDatabaseWriteStatistics represents database channel write statistics.

func NewBrokerDatabaseWriteStatistics 

func NewBrokerDatabaseWriteStatistics(database string) *BrokerDatabaseWriteStatistics

NewBrokerDatabaseWriteStatistics creates a database channel write statistics.

type BrokerFamilyWriteStatistics 

type BrokerFamilyWriteStatistics struct {
	ActiveWriteFamilies  *linmetric.BoundGauge   // number of current active replica family channel
	BatchMetrics         *linmetric.BoundCounter // batch into memory chunk success count
	BatchMetricFailures  *linmetric.BoundCounter // batch into memory chunk failure count
	PendingSend          *linmetric.BoundGauge   // number of pending send message
	SendSuccess          *linmetric.BoundCounter // send message success count
	SendFailure          *linmetric.BoundCounter // send message failure count
	SendSize             *linmetric.BoundCounter // bytes of send message
	Retry                *linmetric.BoundCounter // retry count
	RetryDrop            *linmetric.BoundCounter // number of drop message after too many retry
	CreateStream         *linmetric.BoundCounter // create replica stream success count
	CreateStreamFailures *linmetric.BoundCounter // create replica stream failure count
	CloseStream          *linmetric.BoundCounter // close replica stream success count
	CloseStreamFailures  *linmetric.BoundCounter // close replica stream failure count
	LeaderChanged        *linmetric.BoundCounter // shard leader changed
}

BrokerFamilyWriteStatistics represents family channel write statistics.

func NewBrokerFamilyWriteStatistics 

func NewBrokerFamilyWriteStatistics(database string) *BrokerFamilyWriteStatistics

NewBrokerFamilyWriteStatistics creates a family channel write statistics.

type CommonIngestionStatistics 

type CommonIngestionStatistics struct {
	Duration *linmetric.DeltaHistogramVec // ingest duration(include count)
}

CommonIngestionStatistics represents ingestion common statistics.

func NewCommonIngestionStatistics 

func NewCommonIngestionStatistics() *CommonIngestionStatistics

NewCommonIngestionStatistics creates an ingestion common statistics.

type ConcurrentStatistics 

type ConcurrentStatistics struct {
	WorkersAlive       *linmetric.BoundGauge     // current workers count in use
	WorkersCreated     *linmetric.BoundCounter   // workers created count since start
	WorkersKilled      *linmetric.BoundCounter   // workers killed since start
	TasksConsumed      *linmetric.BoundCounter   // tasks consumed count
	TasksRejected      *linmetric.BoundCounter   // tasks rejected count
	TasksPanic         *linmetric.BoundCounter   // tasks execute panic count
	TasksWaitingTime   *linmetric.BoundHistogram // tasks waiting time
	TasksExecutingTime *linmetric.BoundHistogram // tasks executing time with waiting period
}

ConcurrentStatistics represents concurrent pool statistics.

func NewConcurrentStatistics 

func NewConcurrentStatistics(poolName string, registry *linmetric.Registry) *ConcurrentStatistics

NewConcurrentStatistics creates concurrent statistics.

type ConnStatistics 

type ConnStatistics struct {
	Accept         *linmetric.BoundCounter // accept total count
	AcceptFailures *linmetric.BoundCounter // accept failure
	ActiveConn     *linmetric.BoundGauge   // current active connections
	Read           *linmetric.BoundCounter // read total count
	ReadBytes      *linmetric.BoundCounter // read byte size
	ReadFailures   *linmetric.BoundCounter // read failure
	Write          *linmetric.BoundCounter // write total count
	WriteBytes     *linmetric.BoundCounter // write byte size
	WriteFailures  *linmetric.BoundCounter // write failure
	Close          *linmetric.BoundCounter // close total count
	CloseFailures  *linmetric.BoundCounter // close failure
}

ConnStatistics represents tpc connection statistics.

func NewConnStatistics 

func NewConnStatistics(r *linmetric.Registry, addr string) *ConnStatistics

NewConnStatistics creates tcp connection statistics.

type DatabaseStatistics 

type DatabaseStatistics struct {
	MetaDBFlushFailures *linmetric.BoundCounter   // flush metadata database failure
	MetaDBFlushDuration *linmetric.BoundHistogram // flush metadata database duration(include count)
}

DatabaseStatistics represents database statistics.

func NewDatabaseStatistics 

func NewDatabaseStatistics(database string) *DatabaseStatistics

NewDatabaseStatistics creates a database statistics.

type FamilyStatistics 

type FamilyStatistics struct {
	ActiveFamilies      *linmetric.BoundGauge     // number of current active families
	WriteBatches        *linmetric.BoundCounter   // write batch count
	WriteMetrics        *linmetric.BoundCounter   // write metric success count
	WriteFields         *linmetric.BoundCounter   // write field data point success count
	WriteMetricFailures *linmetric.BoundCounter   // write metric failures
	MemDBTotalSize      *linmetric.BoundGauge     // total memory size of memory database
	ActiveMemDBs        *linmetric.BoundGauge     // number of current active memory database
	MemDBFlushFailures  *linmetric.BoundCounter   // flush memory database failure
	MemDBFlushDuration  *linmetric.BoundHistogram // flush memory database duration(include count)
}

FamilyStatistics represents family statistics.

func NewFamilyStatistics 

func NewFamilyStatistics(database, shard string) *FamilyStatistics

NewFamilyStatistics creates a family statistics.

type FlatIngestionStatistics 

type FlatIngestionStatistics struct {
	CorruptedData   *linmetric.BoundCounter // corrupted when parse
	DroppedMetric   *linmetric.BoundCounter // drop when append
	IngestedMetrics *linmetric.BoundCounter // ingested metrics
	ReadBytes       *linmetric.BoundCounter // read data bytes
	LT10KiBCounter  *linmetric.BoundCounter // <=10k count
	LT100KiBCounter *linmetric.BoundCounter // <=100k count
	LT1MiBCounter   *linmetric.BoundCounter // <=1mb count
	LT10MiBCounter  *linmetric.BoundCounter // <=10mb count
	GT10MiBCounter  *linmetric.BoundCounter // >=10mb count
}

FlatIngestionStatistics represents flot ingestion statistics.

func NewFlatIngestionStatistics 

func NewFlatIngestionStatistics() *FlatIngestionStatistics

NewFlatIngestionStatistics creates a flat ingestion statistics.

type GRPCServerStatistics 

type GRPCServerStatistics struct {
	Panics *linmetric.BoundCounter // panic when grpc server handle request
}

GRPCServerStatistics represents grpc server statistics.

func NewGRPCServerStatistics 

func NewGRPCServerStatistics(registry *linmetric.Registry) *GRPCServerStatistics

NewGRPCServerStatistics creates grpc server statistics.

type GRPCStreamStatistics 

type GRPCStreamStatistics struct {
	MsgReceivedFailures *linmetric.BoundCounter   // receive msg failure
	MsgSentFailures     *linmetric.BoundCounter   // send msg failure
	MsgReceivedDuration *linmetric.BoundHistogram // receive msg duration, include receive total count/handle duration
	MsgSentDuration     *linmetric.BoundHistogram // send msg duration, include send total count
}

GRPCStreamStatistics represents stream grpc client/server statistics.

func NewGRPCStreamClientStatistics 

func NewGRPCStreamClientStatistics(registry *linmetric.Registry, grpcType, grpcService, grpcMethod string) *GRPCStreamStatistics

NewGRPCStreamClientStatistics creates stream grpc client statistics.

func NewGRPCStreamServerStatistics 

func NewGRPCStreamServerStatistics(registry *linmetric.Registry, grpcType, grpcService, grpcMethod string) *GRPCStreamStatistics

NewGRPCStreamServerStatistics creates stream grpc server statistics.

type GRPCUnaryStatistics 

type GRPCUnaryStatistics struct {
	Failures *linmetric.DeltaCounterVec   // handle msg failure
	Duration *linmetric.DeltaHistogramVec // handle msg duration
}

GRPCUnaryStatistics represents unary grpc client/server statistics.

func NewGRPCUnaryClientStatistics 

func NewGRPCUnaryClientStatistics(registry *linmetric.Registry) *GRPCUnaryStatistics

NewGRPCUnaryClientStatistics creates unary grpc client statistics.

func NewGRPCUnaryServerStatistics 

func NewGRPCUnaryServerStatistics(registry *linmetric.Registry) *GRPCUnaryStatistics

NewGRPCUnaryServerStatistics creates unary grpc server statistics.

type IndexDBStatistics 

type IndexDBStatistics = struct {
	BuildInvertedIndex *linmetric.BoundCounter // build inverted index count
}

IndexDBStatistics represents index database statistics.

func NewIndexDBStatistics 

func NewIndexDBStatistics(database string) *IndexDBStatistics

NewIndexDBStatistics creates an index database statistics.

type InfluxIngestionStatistics 

type InfluxIngestionStatistics struct {
	CorruptedData   *linmetric.BoundCounter // corrupted when parse
	IngestedMetrics *linmetric.BoundCounter // ingested metrics
	IngestedFields  *linmetric.BoundCounter // ingested fields
	ReadBytes       *linmetric.BoundCounter // read data bytes
	DroppedMetrics  *linmetric.BoundCounter // drop metric when append
	DroppedFields   *linmetric.BoundCounter // drop field when append
}

InfluxIngestionStatistics represents influx ingestion statistics.

func NewInfluxIngestionStatistics 

func NewInfluxIngestionStatistics() *InfluxIngestionStatistics

NewInfluxIngestionStatistics creates an influx ingestion statistics.

type LimitStatistics 

type LimitStatistics struct {
	Throttles *linmetric.BoundCounter // number of reaches the max-concurrency
	Timeouts  *linmetric.BoundCounter // number pending and then timeout
	Processed *linmetric.BoundCounter // number of processed requests
}

LimitStatistics represents rate limit statistics.

func NewLimitStatistics 

func NewLimitStatistics(limitType string, registry *linmetric.Registry) *LimitStatistics

NewLimitStatistics creates a rate limit statistics.

type MasterStatistics 

type MasterStatistics struct {
	FailOvers        *linmetric.BoundCounter // master fail over successfully
	FailOverFailures *linmetric.BoundCounter // master fail over failure
	Reassigns        *linmetric.BoundCounter // master reassign successfully
	ReassignFailures *linmetric.BoundCounter // master reassign failure
}

MasterStatistics represents master statistics.

func NewMasterStatistics 

func NewMasterStatistics() *MasterStatistics

NewMasterStatistics creates a master statistics.

type MemDBStatistics 

type MemDBStatistics = struct {
	AllocatedPages       *linmetric.BoundCounter // allocate temp memory page success
	AllocatePageFailures *linmetric.BoundCounter // allocate temp memory page failures
}

MemDBStatistics represents memory database statistics.

func NewMemDBStatistics 

func NewMemDBStatistics(database string) *MemDBStatistics

NewMemDBStatistics create a memory database statistics.

type MetaDBStatistics 

type MetaDBStatistics struct {
	GenMetricIDs        *linmetric.BoundCounter // generate metric id success
	GenMetricIDFailures *linmetric.BoundCounter // generate metric id failure
	GenFieldIDs         *linmetric.BoundCounter // generate field id success
	GenFieldIDFailures  *linmetric.BoundCounter // generate field id failure
	GenTagKeyIDs        *linmetric.BoundCounter // generate tag key id success
	GenTagKeyIDFailures *linmetric.BoundCounter // generate tag key id failure
}

MetaDBStatistics represents metadata database statistics.

func NewMetaDBStatistics 

func NewMetaDBStatistics(database string) *MetaDBStatistics

NewMetaDBStatistics create a metadata database statistics.

type NativeIngestionStatistics 

type NativeIngestionStatistics struct {
	CorruptedData   *linmetric.BoundCounter // corrupted when parse
	IngestedMetrics *linmetric.BoundCounter // ingested metrics
	ReadBytes       *linmetric.BoundCounter // read data bytes
	DroppedMetrics  *linmetric.BoundCounter // drop metric when append
}

NativeIngestionStatistics represents native ingestion statistics.

func NewNativeIngestionStatistics 

func NewNativeIngestionStatistics() *NativeIngestionStatistics

NewNativeIngestionStatistics creates a native ingestion statistics.

type QueryStatistics added in v0.2.4 

type QueryStatistics struct {
	CreatedTasks *linmetric.BoundCounter // create query task
	ExpireTasks  *linmetric.BoundCounter // task expire, long-term no response
	AliveTask    *linmetric.BoundGauge   // current executing task(alive)
	EmitResponse *linmetric.BoundCounter // emit response to parent node
	OmitResponse *linmetric.BoundCounter // omit response because task evicted
}

QueryStatistics represents query statistics.

func NewQueryStatistics added in v0.2.4 

func NewQueryStatistics(registry *linmetric.Registry) *QueryStatistics

NewQueryStatistics creates a query statistics.

type RuntimeStatistics 

type RuntimeStatistics struct {
	Routines     *linmetric.BoundGauge   // the number of goroutines
	Threads      *linmetric.BoundGauge   // the number of records in the thread creation profile
	Alloc        *linmetric.BoundGauge   // bytes of allocated heap objects
	TotalAlloc   *linmetric.BoundCounter // cumulative bytes allocated for heap objects
	Sys          *linmetric.BoundGauge   // the total bytes of memory obtained from the OS
	LooksUp      *linmetric.BoundCounter // the number of pointer lookups performed by the runtime
	Mallocs      *linmetric.BoundCounter // the cumulative count of heap objects allocated
	Frees        *linmetric.BoundCounter // the cumulative count of heap objects freed
	HeapAlloc    *linmetric.BoundGauge   // bytes of allocated heap objects
	HeapSys      *linmetric.BoundGauge   // bytes of heap memory obtained from the OS
	HeadIdle     *linmetric.BoundGauge   // bytes in idle (unused) spans
	HeapInuse    *linmetric.BoundGauge   // bytes in in-use spans
	HeapReleased *linmetric.BoundGauge   // bytes of physical memory returned to the OS
	HeapObjects  *linmetric.BoundGauge   // the number of allocated heap objects
	StackInUse   *linmetric.BoundGauge   // bytes in stack spans
	StackSys     *linmetric.BoundGauge   // bytes of stack memory obtained from the OS
	MSpanInuse   *linmetric.BoundGauge   // bytes of allocated mspan structures
	MSpanSys     *linmetric.BoundGauge   // bytes of memory obtained from the OS for mspan
	MCacheInuse  *linmetric.BoundGauge   // bytes of allocated mcache structures
	MCacheSys    *linmetric.BoundGauge   // bytes of memory obtained from the OS for mcache structures
	BuckHashSys  *linmetric.BoundGauge   // bytes of memory in profiling bucket hash tables
	GCSys        *linmetric.BoundGauge   // bytes of memory in garbage collection metadata
	OtherSys     *linmetric.BoundGauge   // bytes of memory in miscellaneous off-heap
	NextGC       *linmetric.BoundGauge   // the target heap size of the next GC cycle
	LastGC       *linmetric.BoundGauge   // the time the last garbage collection finished
	// the fraction of this program's available  CPU time used by the GC since the program started.
	GCCPUFraction *linmetric.BoundGauge
}

RuntimeStatistics represents golang runtime statistics.

func NewRuntimeStatistics 

func NewRuntimeStatistics(registry *linmetric.Registry) *RuntimeStatistics

NewRuntimeStatistics creates a golang runtime statistics.

type ShardLeaderStatistics 

type ShardLeaderStatistics struct {
	LeaderElections     *linmetric.BoundCounter // shard leader elect successfully
	LeaderElectFailures *linmetric.BoundCounter // shard leader elect failure
}

ShardLeaderStatistics represents shard leader elect statistics.

func NewShardLeaderStatistics 

func NewShardLeaderStatistics() *ShardLeaderStatistics

NewShardLeaderStatistics create a shard leader elect statistics.

type ShardStatistics 

type ShardStatistics struct {
	LookupMetricMetaFailures *linmetric.BoundCounter   // lookup meta of metric failure
	IndexDBFlushDuration     *linmetric.BoundHistogram // flush index database duration(include count)
	IndexDBFlushFailures     *linmetric.BoundCounter   // flush index database failure
}

ShardStatistics represents shard statistics.

func NewShardStatistics 

func NewShardStatistics(database, shard string) *ShardStatistics

NewShardStatistics creates a shard statistics.

type StateManagerStatistics 

type StateManagerStatistics struct {
	HandleEvents       *linmetric.DeltaCounterVec // handle event success count
	HandleEventFailure *linmetric.DeltaCounterVec // handle event failure count
	Panics             *linmetric.DeltaCounterVec // panic count when handle event
}

StateManagerStatistics represents state manager statistics.

func NewStateManagerStatistics 

func NewStateManagerStatistics(registry *linmetric.Registry) *StateManagerStatistics

NewStateManagerStatistics creates a state manager statistics.

type StorageLocalReplicatorStatistics 

type StorageLocalReplicatorStatistics struct {
	DecompressFailures *linmetric.BoundCounter // decompress message failure count
	ReplicaFailures    *linmetric.BoundCounter // replica failure count
	ReplicaRows        *linmetric.BoundCounter // row number of replica
	AckSequence        *linmetric.BoundCounter // ack persist sequence count
	InvalidSequence    *linmetric.BoundCounter // invalid replica sequence count
}

StorageLocalReplicatorStatistics represents local replicator statistics.

func NewStorageLocalReplicatorStatistics 

func NewStorageLocalReplicatorStatistics(database, shard string) *StorageLocalReplicatorStatistics

NewStorageLocalReplicatorStatistics creates a storage local replicator statistics.

type StorageQueryStatistics 

type StorageQueryStatistics struct {
	MetricQuery         *linmetric.BoundCounter // execute metric query success(just plan it)
	MetricQueryFailures *linmetric.BoundCounter // execute metric query failure
	MetaQuery           *linmetric.BoundCounter // metadata query success
	MetaQueryFailures   *linmetric.BoundCounter // metadata query failure
	OmitRequest         *linmetric.BoundCounter // omit request(task no belong to current node, wrong stream etc.)
}

StorageQueryStatistics represents storage query statistics.

func NewStorageQueryStatistics 

func NewStorageQueryStatistics() *StorageQueryStatistics

NewStorageQueryStatistics creates a storage query statistics.

type StorageRemoteReplicatorStatistics 

type StorageRemoteReplicatorStatistics struct {
	NotReady                       *linmetric.BoundCounter // remote replicator channel not ready
	FollowerOffline                *linmetric.BoundCounter // remote follower node offline
	NeedCloseLastStream            *linmetric.BoundCounter // need close last stream, when do re-connection
	CloseLastStreamFailures        *linmetric.BoundCounter // close last stream failure
	CreateReplicaCli               *linmetric.BoundCounter // create replica client success
	CreateReplicaCliFailures       *linmetric.BoundCounter // create replica client failure
	CreateReplicaStream            *linmetric.BoundCounter // create replica stream success
	CreateReplicaStreamFailures    *linmetric.BoundCounter // create replica stream failure
	GetLastAckFailures             *linmetric.BoundCounter // get last ack sequence from remote follower failure
	ResetFollowerAppendIdx         *linmetric.BoundCounter // reset follower append index success
	ResetFollowerAppendIdxFailures *linmetric.BoundCounter // reset follower append index failure
	ResetAppendIdx                 *linmetric.BoundCounter // reset current leader local append index
	ResetReplicaIdx                *linmetric.BoundCounter // reset current leader replica index success
	ResetReplicaIdxFailures        *linmetric.BoundCounter // reset current leader replica index failure
	SendMsg                        *linmetric.BoundCounter // send replica msg success
	SendMsgFailures                *linmetric.BoundCounter // send replica msg failure
	ReceiveMsg                     *linmetric.BoundCounter // receive replica resp success
	ReceiveMsgFailures             *linmetric.BoundCounter // receive replica resp failure
	AckSequence                    *linmetric.BoundCounter // ack replica successfully sequence count
	InvalidAckSequence             *linmetric.BoundCounter // get wrong replica ack sequence from follower
}

StorageRemoteReplicatorStatistics represents remote replicator statistics.

func NewStorageRemoteReplicatorStatistics 

func NewStorageRemoteReplicatorStatistics(database, shard string) *StorageRemoteReplicatorStatistics

NewStorageRemoteReplicatorStatistics creates remote replicator statistics.

type StorageReplicatorRunnerStatistics 

type StorageReplicatorRunnerStatistics struct {
	ActiveReplicators      *linmetric.BoundGauge   // number of current active local replicator
	ReplicaPanics          *linmetric.BoundCounter // replica panic count
	ConsumeMessage         *linmetric.BoundCounter // get message success count
	ConsumeMessageFailures *linmetric.BoundCounter // get message failure count
	ReplicaLag             *linmetric.BoundGauge   // replica lag message count
	ReplicaBytes           *linmetric.BoundCounter // bytes of replica data
	Replica                *linmetric.BoundCounter // replica success count
}

StorageReplicatorRunnerStatistics represents storage replicator runner statistics.

func NewStorageReplicatorRunnerStatistics 

func NewStorageReplicatorRunnerStatistics(replicatorType, database, shard string) *StorageReplicatorRunnerStatistics

NewStorageReplicatorRunnerStatistics creates storage replicator runner statistics.

type StorageWriteAheadLogStatistics 

type StorageWriteAheadLogStatistics struct {
	ReceiveWriteSize   *linmetric.BoundCounter // receive write request bytes(broker->leader)
	WriteWAL           *linmetric.BoundCounter // write wal success(broker->leader)
	WriteWALFailures   *linmetric.BoundCounter // write wal failure(broker->leader)
	ReceiveReplicaSize *linmetric.BoundCounter // receive replica request bytes(storage leader->follower)
	ReplicaWAL         *linmetric.BoundCounter // replica wal success(storage leader->follower)
	ReplicaWALFailures *linmetric.BoundCounter // replica wal failure(storage leader->follower)
}

StorageWriteAheadLogStatistics represents storage write ahead log statistics.

func NewStorageWriteAheadLogStatistics 

func NewStorageWriteAheadLogStatistics(database, shard string) *StorageWriteAheadLogStatistics

NewStorageWriteAheadLogStatistics creates a storage write ahead log statistics.

type SystemStatistics 

type SystemStatistics struct {
	// memory
	MemTotal *linmetric.BoundGauge // Total amount of RAM on this system
	MemUsed  *linmetric.BoundGauge // RAM used by programs
	MemFree  *linmetric.BoundGauge // Free RAM
	MemUsage *linmetric.BoundGauge // Percentage of RAM used by programs
	// cpu
	Idle    *linmetric.BoundGauge // CPU time that's not actively being used
	Nice    *linmetric.BoundGauge // CPU time used by processes that have a positive niceness
	System  *linmetric.BoundGauge // CPU time used by the kernel
	User    *linmetric.BoundGauge // CPU time used by user space processes
	Irq     *linmetric.BoundGauge // Interrupt Requests
	Steal   *linmetric.BoundGauge // The percentage of time a virtual CPU waits for a real CPU
	SoftIrq *linmetric.BoundGauge // The kernel is servicing interrupt requests (IRQs)
	IOWait  *linmetric.BoundGauge // It marks time spent waiting for input or output operations
	// disk usage
	DiskTotal *linmetric.BoundGauge // Total amount of disk
	DiskUsed  *linmetric.BoundGauge // Disk used by programs
	DiskFree  *linmetric.BoundGauge // Free disk
	DiskUsage *linmetric.BoundGauge // Percentage of disk used by programs
	// disk inode
	INodesTotal *linmetric.BoundGauge // Total amount of inode
	INodesUsed  *linmetric.BoundGauge // INode used by programs
	INodesFree  *linmetric.BoundGauge // Free inode
	INodesUsage *linmetric.BoundGauge // Percentage of inode used by programs
	// net
	NetBytesSent   *linmetric.DeltaCounterVec // number of bytes sent
	NetBytesRecv   *linmetric.DeltaCounterVec // number of bytes received
	NetPacketsSent *linmetric.DeltaCounterVec // number of packets sent
	NetPacketsRecv *linmetric.DeltaCounterVec // number of packets received
	NetErrIn       *linmetric.DeltaCounterVec // total number of errors while receiving
	NetErrOut      *linmetric.DeltaCounterVec // total number of errors while sending
	NetDropIn      *linmetric.DeltaCounterVec // total number of incoming packets which were dropped
	NetDropOut     *linmetric.DeltaCounterVec // total number of outgoing packets which were dropped (always 0 on OSX and BSD)
}

SystemStatistics represents system statistics.

func NewSystemStatistics 

func NewSystemStatistics(registry *linmetric.Registry) *SystemStatistics

NewSystemStatistics creates a system statistics.

type TagMetaStatistics 

type TagMetaStatistics struct {
	GenTagValueIDs        *linmetric.BoundCounter // generate tag value id success
	GenTagValueIDFailures *linmetric.BoundCounter // generate tag value id failure
}

TagMetaStatistics represents tag metadata statistics.

func NewTagMetaStatistics 

func NewTagMetaStatistics(database string) *TagMetaStatistics

NewTagMetaStatistics creates a tag metadata statistics.

type TransportStatistics added in v0.2.4 

type TransportStatistics struct {
	SentRequest          *linmetric.BoundCounter // send request success
	SentRequestFailures  *linmetric.BoundCounter // send request failure
	SentResponses        *linmetric.BoundCounter // send response to parent success
	SentResponseFailures *linmetric.BoundCounter // send response failure
}

TransportStatistics represents request/response transport statistics.

func NewTransportStatistics added in v0.2.4 

func NewTransportStatistics(registry *linmetric.Registry) *TransportStatistics

NewTransportStatistics creates a transport statistics.

Source Files

View all Source files

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.