telemetryspec

type AccountRegisteredEventDetails struct {
	Address string
}

type AccountsUpdateMetrics struct {
	StartRound                uint64
	RoundsCount               uint64
	OldAccountPreloadDuration time.Duration
	MerkleTrieUpdateDuration  time.Duration
	AccountsWritingDuration   time.Duration
	DatabaseCommitDuration    time.Duration
	MemoryUpdatesDuration     time.Duration
	UpdatedAccountsCount      uint64
	UpdatedResourcesCount     uint64
	UpdatedCreatablesCount    uint64
}

type AssembleBlockMetrics struct {
	AssembleBlockStats
}

type AssembleBlockStats struct {
	StartCount                int
	IncludedCount             int // number of transactions that are included in a block
	InvalidCount              int // number of transaction groups that are included in a block
	MinFeeErrorCount          int // number of transactions excluded because the fee is too low
	LogicErrorCount           int // number of transactions excluded due to logic error (contract no longer valid)
	ExpiredCount              int // number of transactions removed because of expiration
	ExpiredLongLivedCount     int // number of expired transactions with non-super short LastValid values
	LeaseErrorCount           int // number of transactions removed because it has an already used lease
	MinFee                    uint64
	MaxFee                    uint64
	AverageFee                uint64
	MinLength                 int
	MaxLength                 int
	MinPriority               uint64
	MaxPriority               uint64
	CommittedCount            int // number of transaction blocks that are included in a block
	StopReason                string
	TotalLength               uint64
	EarlyCommittedCount       uint64 // number of transaction groups that were pending on the transaction pool but have been included in previous block
	Nanoseconds               int64
	ProcessingTime            transactionProcessingTimeDistribution
	BlockGenerationDuration   uint64
	TransactionsLoopStartTime int64
	StateProofNextRound       uint64 // next round for which state proof if expected
	StateProofStats           StateProofStats
}

type BalancesAccountVacuumEventDetails struct {
	// VacuumTimeNanoseconds is the total amount of time, in nanoseconds, that the vacuum operation took
	VacuumTimeNanoseconds int64
	// BeforeVacuumPageCount is the number of pages that the balances database had prior of running the vacuuming process.
	BeforeVacuumPageCount uint64
	// AfterVacuumPageCount is the number of pages that the balances database had after running the vacuuming process.
	AfterVacuumPageCount uint64
	// BeforeVacuumSpaceBytes is the number of bytes used by the database prior of running the vacuuming process.
	BeforeVacuumSpaceBytes uint64
	// AfterVacuumSpaceBytes is the number of bytes used by the database after running the vacuuming process.
	AfterVacuumSpaceBytes uint64
}

type BlockAcceptedEventDetails struct {
	Address              string
	Hash                 string
	Round                uint64
	ValidatedAt          time.Duration
	ReceivedAt           time.Duration
	VoteValidatedAt      time.Duration
	DynamicFilterTimeout time.Duration
	PreValidated         bool
	PropBufLen           uint64
	VoteBufLen           uint64
}

type BlockProposedEventDetails struct {
	Address string
	Hash    string
	Round   uint64
	Period  uint64
	Step    uint64
}

type BlockStatsEventDetails struct {
	Hash                string
	OriginalProposer    string
	Round               uint64
	Transactions        uint64
	ActiveUsers         uint64
	AgreementDurationMs uint64
	NetworkDowntimeMs   uint64
}

type CatchpointGenerationEventDetails struct {
	// AccountsRound the round in which the account snapshot is taken
	AccountsRound uint64
	// WritingDuration is the total elapsed time it took to write the catchpoint file.
	WritingDuration uint64
	// CPUTime is the single-core time spent waiting to the catchpoint file to be written.
	// this time excludes all the sleeping time taken, and represent the actual time it would
	// take if we were doing the writing on a dedicated process
	CPUTime uint64
	// BalancesWriteDuration is the time duration it took to write the balances portion
	// ( i.e. update the account balances + update the trie )
	BalancesWriteTime uint64
	// AccountsCount is the number of accounts that were written into the generated catchpoint file
	AccountsCount uint64
	// KVsCount, OnlineAccountsCount, OnlineRoundParamsCount are sizes written into the generated catchpoint file
	KVsCount, OnlineAccountsCount, OnlineRoundParamsCount uint64
	// FileSize is the size of the catchpoint file, in bytes.
	FileSize uint64
	// MerkleTrieRootHash is the merkle trie root hash represents all accounts and kvs
	MerkleTrieRootHash string
	// SPVerificationCtxsHash is the hash of all the state proof verification contexts in the catchpoint
	SPVerificationCtxsHash string
}

type CatchpointRootUpdateEventDetails struct {
	Root                        string
	OldBase                     uint64
	NewBase                     uint64
	NewPageCount                int `json:"npc"`
	NewNodeCount                int `json:"nnc"`
	UpdatedPageCount            int `json:"upc"`
	UpdatedNodeCount            int `json:"unc"`
	DeletedPageCount            int `json:"dpc"`
	FanoutReallocatedNodeCount  int `json:"frnc"`
	PackingReallocatedNodeCount int `json:"prnc"`
	LoadedPages                 int `json:"lp"`
}

type CatchupStartEventDetails struct {
	StartRound uint64
}

type CatchupStopEventDetails struct {
	StartRound uint64
	EndRound   uint64
	Time       time.Duration
	InitSync   bool
}

type Category string

type ConnectPeerFailEventDetails struct {
	Address       string
	TelemetryGUID string `json:"HostName"`
	Incoming      bool
	InstanceName  string
	Reason        string
}

type DeadManTriggeredEventDetails struct {
	Timeout      int64
	CurrentBlock uint64
	GoRoutines   string
}

type DisconnectPeerEventDetails struct {
	PeerEventDetails
	Reason string
	// Received message counters for this peer while it was connected
	TXCount, MICount, AVCount, PPCount uint64
}

type EquivocatedVoteEventDetails struct {
	VoterAddress          string
	ProposalHash          string
	Round                 uint64
	Period                uint64
	Step                  uint64
	Weight                uint64
	PreviousProposalHash1 string
	PreviousProposalHash2 string
}

type ErrorOutputEventDetails struct {
	Output string
	Error  string
}

type Event string

type HTTPRequestDetails struct {
	Client       string // The ip address of the remote
	InstanceName string // The node identifier
	Request      string // The request string, i.e. "GET /apache_pb.gif HTTP/1.0"
	StatusCode   uint64 // The response status code
	BodyLength   uint64 // The returned body length, in bytes
	UserAgent    string // The user-agent string ( if any )
}

type HeartbeatEventDetails struct {
	Info struct {
		Version    string `json:"version"`
		VersionNum string `json:"version-num"`
		Channel    string `json:"channel"`
		Branch     string `json:"branch"`
		CommitHash string `json:"commit-hash"`
	} `json:"Metrics"` // backwards compatible name
	Metrics map[string]float64 `json:"m"`
}

type LocalMsgTiming struct {
	// LRFirst is the time a message type is first received. For this to
	// be useful we should test deployments with non-voting nodes.
	LRFirst *TimeWithSender `json:"lrfirst,omitempty"`

	// LRLast is the time a message type is last received (and not filtered).
	LRLast *TimeWithSender `json:"lrlast,omitempty"`

	// LStart is the step start time. We could derive from elsewhere.
	LStart *time.Duration `json:"lstart,omitempty"` // optional

	// LRWin is the time a "winning" message is received, defined for proposals/payloads.
	LRWin *TimeWithSender `json:"lrwin,omitempty"` // optional

	// LRThresh is the time a threshold is triggered locally.
	LRThresh *time.Duration `json:"lrtresh,omitempty"` // optional
}

type Metric string

type MetricDetails interface {
	Identifier() Metric
}

type NameValue struct {
	Name  string
	Value interface{}
}

type NewRoundPeriodDetails struct {
	OldRound  uint64
	OldPeriod uint64
	OldStep   uint64
	NewRound  uint64
	NewPeriod uint64
	NewStep   uint64
	LocalTime time.Time
}

type PartKeyRegisteredEventDetails struct {
	Address    string
	FirstValid uint64
	LastValid  uint64
}

type PeerConnectionDetails struct {
	// Address is the IP address of the remote connected socket
	Address string
	// The TelemetryGUID is the TelemetryGUID passed via the X-Algorand-TelId header during the http connection handshake.
	TelemetryGUID string `json:"HostName"`
	// InstanceName is the node-specific hashed instance name that was passed via X-Algorand-InstanceName header during the http connection handshake.
	InstanceName string
	// ConnectionDuration is the duration of the connection, in seconds.
	ConnectionDuration uint
	// Endpoint is the dialed-to address, for an outgoing connection. Not being used for incoming connection.
	Endpoint string `json:",omitempty"`
	// MessageDelay is the average relative message delay. Not being used for incoming connection.
	MessageDelay int64 `json:",omitempty"`
	// DuplicateFilterCount is the number of times this peer has sent us a message hash to filter that it had already sent before.
	DuplicateFilterCount uint64
	// These message counters count received messages from this peer.
	TXCount, MICount, AVCount, PPCount, UNKCount uint64
	// TCPInfo provides connection measurements from TCP.
	TCP util.TCPInfo `json:",omitempty"`
}

type PeerEventDetails struct {
	Address       string
	TelemetryGUID string `json:"HostName"`
	Incoming      bool
	InstanceName  string
	// Endpoint is the dialed-to address, for an outgoing connection. Not being used for incoming connection.
	Endpoint string `json:",omitempty"`
	// MessageDelay is the average relative message delay. Not being used for incoming connection.
	MessageDelay int64 `json:",omitempty"`
}

type PeersConnectionDetails struct {
	IncomingPeers []PeerConnectionDetails
	OutgoingPeers []PeerConnectionDetails
}

type ProcessBlockMetrics struct {
	KnownCommittedCount   uint
	UnknownCommittedCount uint
	ExpiredCount          uint
	RemovedInvalidCount   uint
}

type RoundTimingMetrics struct {
	// We keep track of timingInfo for period 0 step <= 3 only, for brevity
	Round          uint64 `json:"round"`
	ConcludingStep uint64 `json:"laststep"`

	// Local Timings. Eventually, we could
	// attach timing information at the network layer to messages - but that is a
	// larger change I'd rather avoid for now. However, this means right now we
	// can only recover transit time information through telemetry, so we'll save
	// logging more thorough delivery distributions for a second pass. (-ben)
	LRoundStart time.Time `json:"lroundstart"`

	// LVotes contains times this player (would have) sent corresponding votes,
	// and times this player receives votes.
	LVotes map[uint64]LocalMsgTiming `json:"lvotes"`

	// LPayload contains times this player received payloads relevant to this round.
	LPayload LocalMsgTiming `json:"lpayload"`

	// BlockAssemble time specifies the duration from start of Round to Block Assembly completion
	BlockAssemble time.Duration `json:"lblockassemble"`

	// Payload Validation time contains the event times for Payload validation, once for each account
	PayloadValidation LocalMsgTiming `json:"lpayloadvalidation"`
}

type StartupEventDetails struct {
	Version      string
	CommitHash   string
	Branch       string
	Channel      string
	InstanceHash string
	Overrides    []NameValue
}

type StateProofStats struct {
	ProvenWeight   uint64
	SignedWeight   uint64
	NumReveals     int
	NumPosToReveal int
	TxnSize        int
}

type TimeWithSender struct {
	T      time.Duration `json:"t"`
	Sender string        `json:"sender"`
}

type VoteEventDetails struct {
	Address   string
	Hash      string
	Round     uint64
	Period    uint64
	Step      uint64
	Weight    uint64
	Recovered bool
}

type VoteRejectedEventDetails struct {
	VoteEventDetails
	Reason string
}