875 lines
27 KiB
Go
875 lines
27 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/helium-blockchain-exporter/heliumapi"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/prometheus/client_golang/prometheus/promhttp"
|
|
"golang.org/x/time/rate"
|
|
)
|
|
|
|
// metricInfo is a metric exported by the helium blockchain exporter
|
|
type metricInfo struct {
|
|
Desc *prometheus.Desc
|
|
Type prometheus.ValueType
|
|
}
|
|
|
|
// Exporter collect metrics from the helium blockchain api and exports them as prometheus metrics.
|
|
type Exporter struct {
|
|
Accounts []Account
|
|
StartTime time.Time
|
|
}
|
|
|
|
// NewExporter returns an initialized Exporter
|
|
func NewExporter(accountAddress []string) (*Exporter, error) {
|
|
accounts := make([]Account, 0)
|
|
for _, accountAddress := range accountAddress {
|
|
if accountAddress != "" {
|
|
accounts = append(accounts, NewAccount(accountAddress))
|
|
}
|
|
}
|
|
return &Exporter{
|
|
Accounts: accounts,
|
|
StartTime: time.Now(),
|
|
}, nil
|
|
}
|
|
|
|
// Account represents a helium account
|
|
type Account struct {
|
|
Address string
|
|
UpdateLock sync.Mutex
|
|
LastUpdate time.Time
|
|
RewardsTotal map[string]int
|
|
Tx AccountTx
|
|
Hotspots map[string]Hotspot
|
|
}
|
|
|
|
func NewAccount(address string) Account {
|
|
return Account{
|
|
Address: address,
|
|
LastUpdate: time.Now(),
|
|
RewardsTotal: map[string]int{
|
|
"data_credits": 0,
|
|
"poc_challengers": 0,
|
|
"poc_challengees": 0,
|
|
"poc_witnesses": 0,
|
|
},
|
|
Tx: AccountTx{
|
|
DepositTotal: 0,
|
|
WithdrawalTotal: 0,
|
|
},
|
|
Hotspots: map[string]Hotspot{},
|
|
}
|
|
}
|
|
|
|
type AccountTx struct {
|
|
DepositTotal int
|
|
WithdrawalTotal int
|
|
}
|
|
|
|
// Hotspot represents a hotspot
|
|
type Hotspot struct {
|
|
Address string
|
|
LastUpdate time.Time
|
|
RewardsTotal map[string]int
|
|
}
|
|
|
|
func NewHotspot(address string) Hotspot {
|
|
return Hotspot{
|
|
Address: address,
|
|
LastUpdate: time.Now(),
|
|
RewardsTotal: map[string]int{
|
|
"data_credits": 0,
|
|
"poc_challengers": 0,
|
|
"poc_challengees": 0,
|
|
"poc_witnesses": 0,
|
|
},
|
|
}
|
|
}
|
|
|
|
const (
|
|
namespace = "helium"
|
|
blockchain_oracle_factor = 100000000
|
|
blockchain_hnt_factor = 100000000
|
|
)
|
|
|
|
var (
|
|
// labels
|
|
commonAccountLabels = []string{"account"}
|
|
commonHotspotLabels = append(commonAccountLabels, "hotspot", "hotspot_name")
|
|
|
|
// exporter metrics
|
|
|
|
// helium oracle metrics
|
|
oraclePrice = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "oracle", "price_usd"),
|
|
"The oracle price of an HNT token in USD.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
|
|
// helium stats metrics
|
|
statsValidators = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "validators"),
|
|
"The total number of validators.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsOuis = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "ouis"),
|
|
"The total number of organization unique identifiers.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsHotspotsDataOnly = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "hotspots_dataonly"),
|
|
"The total number of data only hotspots.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsBlocks = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "blocks"),
|
|
"The height of the blockchain.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsChallenges = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "challenges"),
|
|
"The total number of challenges.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsCities = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "cities"),
|
|
"The number of cities with at least one helium hotspot.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsConsensusGroups = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "consensus_groups"),
|
|
"The total number of consensus groups.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsCountries = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "countries"),
|
|
"The number of countries with at least on helium hotspot.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsHotspots = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "hotspots"),
|
|
"The total number of hotspots.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
statsTokenSupply = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "stats", "token"),
|
|
"The total supply of HNT tokens in circulation.",
|
|
nil, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
|
|
// helium account metrics
|
|
accountBalanceHnt = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "account", "balance_hnt"),
|
|
"The number of HNT token owned by an account.",
|
|
commonAccountLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
accountActivity = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "account", "activity_total"),
|
|
"The total number of time an activity occurred in an account.",
|
|
append(commonAccountLabels, "type"), nil,
|
|
),
|
|
prometheus.CounterValue,
|
|
}
|
|
accountRewardsHnt = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "account", "rewards_hnt_total"),
|
|
"The number of HNT token rewarded to an account.",
|
|
append(commonAccountLabels, "type"), nil,
|
|
),
|
|
prometheus.CounterValue,
|
|
}
|
|
accountDepositsHnt = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "account", "deposits_hnt_total"),
|
|
"The number of HNT tokens deposited to an account.",
|
|
commonAccountLabels, nil,
|
|
),
|
|
prometheus.CounterValue,
|
|
}
|
|
accountWithdrawalsHnt = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "account", "withdrawals_hnt_total"),
|
|
"The number of HNT tokens withdrawn from an account.",
|
|
commonAccountLabels, nil,
|
|
),
|
|
prometheus.CounterValue,
|
|
}
|
|
|
|
// helium hotspot metrics
|
|
hotspotUp = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "up"),
|
|
"Whether a hotspot is online.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotRelayed = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "relayed"),
|
|
"Whether a hotspot is relayed.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotBlocks = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "blocks"),
|
|
"The block height of a hotspot. Check on the hotspot itself for the most recent data.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotBlocksDelta = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "blocks_delta"),
|
|
"The gap between the height of a hotspot and the height of the blockchain. A large negative gap may indicate the hotspot is out of sync. Check on the hotspot itself for the most recent data.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotStatusTimestamp = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "status_timestamp"),
|
|
"The the last time a hotspot gossiped its status on the blockchain.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotRewardsScale = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "rewards_scale"),
|
|
"The reward scale of a hotspot.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspot5dWitnesses = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "5d_witnesses"),
|
|
"The number of hotspots that witnessed this hotspot in the last 5 days.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspot5dWitnessed = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "5d_witnessed"),
|
|
"The number of hotspots this hotspot witnessed in the last 5 days.",
|
|
commonHotspotLabels, nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotGeocodeInfo = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "geocode_info"),
|
|
"Information on the location of a hotspot.",
|
|
append(commonHotspotLabels, "lng", "lat", "street", "state", "country", "city"), nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotAntennaInfo = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "antenna_info"),
|
|
"Information on the antenna of a hotspot.",
|
|
append(commonHotspotLabels, "gain", "elevation"), nil,
|
|
),
|
|
prometheus.GaugeValue,
|
|
}
|
|
hotspotActivity = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "activity_total"),
|
|
"The total number of time an activity occurred in a hotspot.",
|
|
append(commonHotspotLabels, "type"), nil,
|
|
),
|
|
prometheus.CounterValue,
|
|
}
|
|
hotspotRewardsHnt = metricInfo{
|
|
prometheus.NewDesc(
|
|
prometheus.BuildFQName(namespace, "hotspot", "rewards_hnt_total"),
|
|
"The number of HNT token rewarded to a hotspot.",
|
|
append(commonHotspotLabels, "type"), nil,
|
|
),
|
|
prometheus.CounterValue,
|
|
}
|
|
)
|
|
|
|
func bool2Float64(b bool) float64 {
|
|
if b {
|
|
return 1.0
|
|
}
|
|
return 0.0
|
|
}
|
|
|
|
// Describe describes all the metrics ever exported by the helium blockchain exporter.
|
|
// implements prometheus.Collector.
|
|
func (e *Exporter) Describe(ch chan<- *prometheus.Desc) {
|
|
ch <- oraclePrice.Desc
|
|
|
|
ch <- statsValidators.Desc
|
|
ch <- statsOuis.Desc
|
|
ch <- statsHotspotsDataOnly.Desc
|
|
ch <- statsBlocks.Desc
|
|
ch <- statsChallenges.Desc
|
|
ch <- statsCities.Desc
|
|
ch <- statsConsensusGroups.Desc
|
|
ch <- statsCountries.Desc
|
|
ch <- statsHotspots.Desc
|
|
ch <- statsTokenSupply.Desc
|
|
|
|
ch <- accountBalanceHnt.Desc
|
|
ch <- accountActivity.Desc
|
|
ch <- accountRewardsHnt.Desc
|
|
ch <- accountDepositsHnt.Desc
|
|
ch <- accountWithdrawalsHnt.Desc
|
|
|
|
ch <- hotspotUp.Desc
|
|
ch <- hotspotRelayed.Desc
|
|
ch <- hotspotBlocksDelta.Desc
|
|
ch <- hotspotBlocks.Desc
|
|
ch <- hotspotStatusTimestamp.Desc
|
|
ch <- hotspotRewardsScale.Desc
|
|
ch <- hotspot5dWitnesses.Desc
|
|
ch <- hotspot5dWitnessed.Desc
|
|
ch <- hotspotGeocodeInfo.Desc
|
|
ch <- hotspotAntennaInfo.Desc
|
|
ch <- hotspotActivity.Desc
|
|
ch <- hotspotRewardsHnt.Desc
|
|
}
|
|
|
|
// Collect fetches the data from the helium blockchain api and delivers them as Prometheus metrics.
|
|
// implements prometheus.Collector.
|
|
func (e *Exporter) Collect(ch chan<- prometheus.Metric) {
|
|
wg := new(sync.WaitGroup)
|
|
|
|
wg.Add(2)
|
|
go e.collectOracleMetrics(wg, ch)
|
|
go e.collectStatsMetrics(wg, ch)
|
|
for i := range e.Accounts {
|
|
wg.Add(4)
|
|
go e.collectAccountMetrics(wg, ch, &e.Accounts[i])
|
|
go e.collectAccountActivityMetrics(wg, ch, &e.Accounts[i])
|
|
go e.collectAccountTransactionsMetrics(wg, ch, &e.Accounts[i])
|
|
|
|
go e.collectHotspotMetrics(wg, ch, &e.Accounts[i])
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
// collectOracleMetrics collect metrics in the oracle group from the helium api
|
|
func (e *Exporter) collectOracleMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric) {
|
|
defer wg.Done()
|
|
|
|
currentOraclePrice, err := heliumapi.GetCurrentOraclePrice()
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
oraclePrice.Desc, oraclePrice.Type, float64(currentOraclePrice.Price)/blockchain_oracle_factor,
|
|
)
|
|
}
|
|
|
|
// collectStatsMetrics collect metrics in the stats group from the helium api
|
|
func (e *Exporter) collectStatsMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric) {
|
|
defer wg.Done()
|
|
|
|
blockchainStats, err := heliumapi.GetBlockchainStats()
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsValidators.Desc, statsValidators.Type, float64(blockchainStats.Counts.Validators),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsOuis.Desc, statsOuis.Type, float64(blockchainStats.Counts.Ouis),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsHotspotsDataOnly.Desc, statsHotspotsDataOnly.Type, float64(blockchainStats.Counts.HotspotsDataonly),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsBlocks.Desc, statsBlocks.Type, float64(blockchainStats.Counts.Blocks),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsChallenges.Desc, statsChallenges.Type, float64(blockchainStats.Counts.Challenges),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsCities.Desc, statsCities.Type, float64(blockchainStats.Counts.Cities),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsConsensusGroups.Desc, statsConsensusGroups.Type, float64(blockchainStats.Counts.ConsensusGroups),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsCountries.Desc, statsCountries.Type, float64(blockchainStats.Counts.Countries),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsHotspots.Desc, statsHotspots.Type, float64(blockchainStats.Counts.Hotspots),
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
statsTokenSupply.Desc, statsTokenSupply.Type, blockchainStats.TokenSupply,
|
|
)
|
|
}
|
|
|
|
// collectStatsMetrics collect metrics in the account group from the helium api
|
|
func (e *Exporter) collectAccountMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account) {
|
|
defer wg.Done()
|
|
|
|
accountForAddress, err := heliumapi.GetAccountForAddress(account.Address)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
accountBalanceHnt.Desc, accountBalanceHnt.Type, float64(accountForAddress.Balance)/blockchain_hnt_factor,
|
|
account.Address,
|
|
)
|
|
}
|
|
|
|
// collectAccountActivityMetrics collect the total number of activities executed by an account from the helium api
|
|
func (e *Exporter) collectAccountActivityMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account) {
|
|
defer wg.Done()
|
|
|
|
accountActivityForAddress, err := heliumapi.GetActivityCountsForAccount(account.Address)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
for accType, count := range *accountActivityForAddress {
|
|
ch <- prometheus.MustNewConstMetric(
|
|
accountActivity.Desc, accountActivity.Type, float64(count),
|
|
account.Address, accType,
|
|
)
|
|
}
|
|
}
|
|
|
|
// collectAccountTransactionsMetrics collect the total deposited/withdrawn by an account from the helium api
|
|
func (e *Exporter) collectAccountTransactionsMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account) {
|
|
defer wg.Done()
|
|
|
|
// We optimize our queries by asking the api only the activities we car about.
|
|
activityTypes := []string{
|
|
"add_gateway_v1",
|
|
"assert_location_v1",
|
|
"assert_location_v2",
|
|
"payment_v1",
|
|
"payment_v2",
|
|
"rewards_v1",
|
|
"rewards_v2",
|
|
"stake_validator_v1",
|
|
"token_burn_v1",
|
|
"transfer_hotspot_v1",
|
|
"unstake_validator_v1",
|
|
}
|
|
|
|
// We can only want to allow a single instance of the routine doing
|
|
// calculations on the deposited and widthdrawn total.
|
|
account.UpdateLock.Lock()
|
|
defer account.UpdateLock.Unlock()
|
|
|
|
// We want to keep in memory the timestamp of the last activity we
|
|
// received from the api. We cannot do something naive like [lastscrape, now]
|
|
// because the api can take a few seconds to sync with the chain and
|
|
// we can miss some activities by doing it that way.
|
|
lastActivityTime := account.LastUpdate.Unix()
|
|
updateLastActivityTime := func(newTime int64) {
|
|
if lastActivityTime < newTime {
|
|
lastActivityTime = newTime
|
|
}
|
|
}
|
|
|
|
// add 1 second to the last update time to avoid querying the same activity twice
|
|
minTime := account.LastUpdate.Add(time.Second * 1)
|
|
// Explicitly set max_time, to avoid issues with server-side caching
|
|
maxTime := time.Now()
|
|
activities, err := heliumapi.GetActivityForAccount(account.Address, activityTypes, &minTime, &maxTime)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
// impl based on https://github.com/helium/hotspot-app/blob/918563fba84d1abf4554a43a4d42bb838d017bd3/src/features/wallet/root/useActivityItem.tsx#L336
|
|
for _, activity := range activities.AddGatewayV1 {
|
|
account.Tx.WithdrawalTotal += activity.StakingFee
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.AssertLocationV1 {
|
|
account.Tx.WithdrawalTotal += activity.StakingFee
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.AssertLocationV2 {
|
|
account.Tx.WithdrawalTotal += activity.StakingFee
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.PaymentV1 {
|
|
if activity.Payer == account.Address {
|
|
account.Tx.WithdrawalTotal += activity.Amount
|
|
} else {
|
|
account.Tx.DepositTotal += activity.Amount
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.PaymentV2 {
|
|
if activity.Payer == account.Address {
|
|
paymentTotal := 0
|
|
for _, payment := range activity.Payments {
|
|
paymentTotal += payment.Amount
|
|
}
|
|
account.Tx.WithdrawalTotal += paymentTotal
|
|
} else {
|
|
for _, payment := range activity.Payments {
|
|
if payment.Payee == account.Address {
|
|
account.Tx.DepositTotal += payment.Amount
|
|
}
|
|
}
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.RewardsV1 {
|
|
for _, reward := range activity.Rewards {
|
|
account.RewardsTotal[reward.Type] += reward.Amount
|
|
account.Tx.DepositTotal += reward.Amount
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.RewardsV2 {
|
|
for _, reward := range activity.Rewards {
|
|
account.RewardsTotal[reward.Type] += reward.Amount
|
|
account.Tx.DepositTotal += reward.Amount
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.StakeValidatorV1 {
|
|
account.Tx.WithdrawalTotal += activity.Stake
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.TokenBurnV1 {
|
|
account.Tx.WithdrawalTotal += activity.Amount
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.TransferHotspotV1 {
|
|
if activity.Buyer == account.Address {
|
|
account.Tx.WithdrawalTotal += activity.AmountToSeller
|
|
} else {
|
|
account.Tx.DepositTotal += activity.AmountToSeller
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.UnstakeValidatorV1 {
|
|
account.Tx.WithdrawalTotal += activity.StakeAmount
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
account.LastUpdate = time.Unix(lastActivityTime, 0)
|
|
|
|
for rType, rTotal := range account.RewardsTotal {
|
|
ch <- prometheus.MustNewConstMetric(
|
|
accountRewardsHnt.Desc, accountRewardsHnt.Type, float64(rTotal)/blockchain_hnt_factor,
|
|
account.Address, rType,
|
|
)
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
accountDepositsHnt.Desc, accountDepositsHnt.Type, float64(account.Tx.DepositTotal)/blockchain_hnt_factor,
|
|
account.Address,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
accountWithdrawalsHnt.Desc, accountWithdrawalsHnt.Type, float64(account.Tx.WithdrawalTotal)/blockchain_hnt_factor,
|
|
account.Address,
|
|
)
|
|
}
|
|
|
|
// collectStatsMetrics collect metrics of the hotspot of an account from the helium api
|
|
func (e *Exporter) collectHotspotMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account) {
|
|
defer wg.Done()
|
|
|
|
hotspotsForAddress, err := heliumapi.GetHotspotsForAccount(account.Address)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
for _, hotspotData := range hotspotsForAddress {
|
|
statusTime, err := time.Parse(time.RFC3339Nano, hotspotData.Status.Timestamp)
|
|
if err != nil {
|
|
log.Println(err)
|
|
continue
|
|
}
|
|
|
|
// collect hotspot metric requiring extra queries in a new routine
|
|
wg.Add(4)
|
|
go e.collectHotspotBlocksDeltaMetrics(wg, ch, account, hotspotData)
|
|
go e.collectHotspotWitnessesMetrics(wg, ch, account, hotspotData)
|
|
// go e.collectHotspotWitnessedMetrics(wg, ch, account, hotspotData)
|
|
go e.collectHotspotActivityMetrics(wg, ch, account, hotspotData)
|
|
go e.collectHotspotRewardsMetrics(wg, ch, account, hotspotData)
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotUp.Desc, hotspotUp.Type, bool2Float64(hotspotData.Status.Online == "online"),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotRelayed.Desc, hotspotRelayed.Type, bool2Float64(len(hotspotData.Status.ListenAddrs) > 0 && strings.HasPrefix(hotspotData.Status.ListenAddrs[0], "/p2p")),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotBlocks.Desc, hotspotBlocks.Type, float64(hotspotData.Status.Height),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotStatusTimestamp.Desc, hotspotStatusTimestamp.Type, float64(statusTime.Unix()),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotRewardsScale.Desc, hotspotRewardsScale.Type, float64(hotspotData.RewardScale),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotGeocodeInfo.Desc, hotspotGeocodeInfo.Type, 1.0,
|
|
account.Address, hotspotData.Address, hotspotData.Name, strconv.FormatFloat(hotspotData.Lng, 'f', 6, 64), strconv.FormatFloat(hotspotData.Lat, 'f', 6, 64), hotspotData.Geocode.LongStreet, hotspotData.Geocode.LongState, hotspotData.Geocode.LongCountry, hotspotData.Geocode.LongCity,
|
|
)
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotAntennaInfo.Desc, hotspotAntennaInfo.Type, 1.0,
|
|
account.Address, hotspotData.Address, hotspotData.Name, strconv.Itoa(hotspotData.Gain), strconv.Itoa(hotspotData.Elevation),
|
|
)
|
|
}
|
|
}
|
|
|
|
// collectHotspotBlocksDeltaMetrics calculate the gap between the block height of a hotstop and the height of the chain
|
|
func (e *Exporter) collectHotspotBlocksDeltaMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account, hotspotData heliumapi.Hotspot) {
|
|
defer wg.Done()
|
|
|
|
delta := 0.
|
|
if hotspotData.Status.Online == "online" && hotspotData.Status.Timestamp != "" {
|
|
statusTime, err := time.Parse(time.RFC3339Nano, hotspotData.Status.Timestamp)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
heightAtUpdate, err := heliumapi.GetHeight(&statusTime)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
delta = float64(hotspotData.Status.Height - heightAtUpdate)
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotBlocksDelta.Desc, hotspotBlocksDelta.Type, delta,
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
}
|
|
|
|
// collectHotspotWitnessesMetrics collect the total number witnesses of a hotspot in the last 5d
|
|
func (e *Exporter) collectHotspotWitnessesMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account, hotspotData heliumapi.Hotspot) {
|
|
defer wg.Done()
|
|
|
|
hotspotWitnesses, err := heliumapi.GetWitnessesForHotspot(hotspotData.Address)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspot5dWitnesses.Desc, hotspotActivity.Type, float64(len(hotspotWitnesses)),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
}
|
|
|
|
// collectHotspotWitnessedMetrics collect the total number hotspots witnessed in the last 5d
|
|
func (e *Exporter) collectHotspotWitnessedMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account, hotspotData heliumapi.Hotspot) {
|
|
defer wg.Done()
|
|
|
|
hotspotWitnessed, err := heliumapi.GetWitnessedForHotspot(hotspotData.Address)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspot5dWitnessed.Desc, hotspotActivity.Type, float64(len(hotspotWitnessed)),
|
|
account.Address, hotspotData.Address, hotspotData.Name,
|
|
)
|
|
}
|
|
|
|
// collectHotspotActivityMetrics collect the total number of activities executed by a hotspot from the helium api
|
|
func (e *Exporter) collectHotspotActivityMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account, hotspotData heliumapi.Hotspot) {
|
|
defer wg.Done()
|
|
|
|
hotspotActivityForAddress, err := heliumapi.GetHotspotActivityCounts(hotspotData.Address)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
for accType, count := range *hotspotActivityForAddress {
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotActivity.Desc, hotspotActivity.Type, float64(count),
|
|
account.Address, hotspotData.Address, hotspotData.Name, accType,
|
|
)
|
|
}
|
|
}
|
|
|
|
// collectHotspotRewardsMetrics collect the total rewards accumulated by a hotspot from the helium api
|
|
func (e *Exporter) collectHotspotRewardsMetrics(wg *sync.WaitGroup, ch chan<- prometheus.Metric, account *Account, hotspotData heliumapi.Hotspot) {
|
|
defer wg.Done()
|
|
|
|
// We optimize our queries by asking the api only the activities we car about.
|
|
activityTypes := []string{
|
|
"rewards_v1",
|
|
"rewards_v2",
|
|
}
|
|
|
|
// TODO: optimize locks
|
|
account.UpdateLock.Lock()
|
|
defer account.UpdateLock.Unlock()
|
|
|
|
hotspot, ok := account.Hotspots[hotspotData.Address]
|
|
if !ok {
|
|
hotspot = NewHotspot(hotspotData.Address)
|
|
account.Hotspots[hotspotData.Address] = hotspot
|
|
}
|
|
|
|
// We want to keep in memory the timestamp of the last activity we
|
|
// received from the api. We cannot do something naive like [lastscrape, now]
|
|
// because the api can take a few seconds to sync with the chain and
|
|
// we can miss some activities by doing it that way.
|
|
lastActivityTime := hotspot.LastUpdate.Unix()
|
|
updateLastActivityTime := func(newTime int64) {
|
|
if lastActivityTime < newTime {
|
|
lastActivityTime = newTime
|
|
}
|
|
}
|
|
|
|
// add 1 second to the last update time to avoid querying the same activity twice
|
|
minTime := hotspot.LastUpdate.Add(time.Second * 1)
|
|
// Explicitly set max_time, to avoid issues with server-side caching
|
|
maxTime := time.Now()
|
|
activities, err := heliumapi.GetHotspotActivity(hotspot.Address, activityTypes, &minTime, &maxTime)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
for _, activity := range activities.RewardsV1 {
|
|
for _, reward := range activity.Rewards {
|
|
hotspot.RewardsTotal[reward.Type] += reward.Amount
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
for _, activity := range activities.RewardsV2 {
|
|
for _, reward := range activity.Rewards {
|
|
hotspot.RewardsTotal[reward.Type] += reward.Amount
|
|
}
|
|
updateLastActivityTime(activity.Time)
|
|
}
|
|
hotspot.LastUpdate = time.Unix(lastActivityTime, 0)
|
|
|
|
for rType, rTotal := range hotspot.RewardsTotal {
|
|
ch <- prometheus.MustNewConstMetric(
|
|
hotspotRewardsHnt.Desc, hotspotRewardsHnt.Type, float64(rTotal)/blockchain_hnt_factor,
|
|
account.Address, hotspot.Address, hotspotData.Name, rType,
|
|
)
|
|
}
|
|
account.Hotspots[hotspot.Address] = hotspot
|
|
}
|
|
|
|
func main() {
|
|
var err error
|
|
|
|
fApiUrl := flag.String("apiUrl", "https://helium-api.stakejoy.com", "The helium api url")
|
|
fApiTimeout := flag.String("apiTimeout", "10s", "The request timeout to the helium api.")
|
|
fApiRateLimit := flag.Int("maxApiRate", 10, "The maximum number of helium api calls per seconds.")
|
|
fHeliumAccounts := flag.String("accounts", "", "A comma-delimited list of helium accounts to scrape (optional)")
|
|
fMetricsPath := flag.String("metricpath", "/metrics", "The metrics path")
|
|
fListenAddress := flag.String("listenAddress", "0.0.0.0", "The http server listen address")
|
|
fListenPort := flag.String("listenPort", "9865", "The http server listen port")
|
|
flag.Parse()
|
|
|
|
heliumapi.ApiUrl = *fApiUrl
|
|
heliumapi.Limiter = rate.NewLimiter(rate.Every(time.Duration(1000/(*fApiRateLimit))*time.Millisecond), *fApiRateLimit)
|
|
heliumapi.ApiTimeout, err = time.ParseDuration(*fApiTimeout)
|
|
if err != nil {
|
|
log.Fatalf("failed to parse apiTimeout: %s", err.Error())
|
|
}
|
|
|
|
heliumAccounts := strings.Split(*fHeliumAccounts, ",")
|
|
serverAddr := *fListenAddress + ":" + *fListenPort
|
|
|
|
e, err := NewExporter(heliumAccounts)
|
|
if err != nil {
|
|
log.Fatalf("failed to start exporter: %s", err.Error())
|
|
}
|
|
|
|
r := prometheus.NewRegistry()
|
|
r.MustRegister(e)
|
|
|
|
// setup http route
|
|
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
_, _ = w.Write([]byte(`<html>
|
|
<head><title>Helium blockchain exporter</title></head>
|
|
<body>
|
|
<h1>Helium blockchain exporter</h1>
|
|
<p><a href='` + *fMetricsPath + `'>Metrics</a></p>
|
|
</body>
|
|
</html>`))
|
|
})
|
|
|
|
http.Handle(*fMetricsPath, promhttp.HandlerFor(r, promhttp.HandlerOpts{}))
|
|
log.Printf("listening on %v\n", serverAddr)
|
|
if err = http.ListenAndServe(serverAddr, nil); err != nil {
|
|
log.Println(err)
|
|
os.Exit(1)
|
|
}
|
|
}
|