Merge pull request #262 from SiaFoundation/christopher/add-block-time-metrics

Add block time metrics

Author: chris124567

api/client.go

@@ -280,6 +280,12 @@ func (c *Client) HostMetrics() (resp explorer.HostMetrics, err error) {
 	return
 }
 
+// BlockTimeMetrics returns the average block time during various intervals.
+func (c *Client) BlockTimeMetrics() (resp explorer.BlockTimeMetrics, err error) {
+	err = c.c.GET(context.Background(), "/metrics/blocktime", &resp)
+	return
+}
+
 // Search returns what type of object an ID is.
 func (c *Client) Search(id string) (resp explorer.SearchType, err error) {
 	err = c.c.GET(context.Background(), fmt.Sprintf("/search/%s", id), &resp)

api/server.go

@@ -54,6 +54,7 @@ type (
 		BestTip(height uint64) (types.ChainIndex, error)
 		Metrics(id types.BlockID) (explorer.Metrics, error)
 		HostMetrics() (explorer.HostMetrics, error)
+		BlockTimeMetrics() (explorer.BlockTimeMetrics, error)
 		Transactions(ids []types.TransactionID) ([]explorer.Transaction, error)
 		TransactionChainIndices(id types.TransactionID, offset, limit uint64) ([]types.ChainIndex, error)
 		V2Transactions(ids []types.TransactionID) ([]explorer.V2Transaction, error)
@@ -299,6 +300,14 @@ func (s *server) hostMetricsHandler(jc jape.Context) {
 	jc.Encode(metrics)
 }
 
+func (s *server) blockTimeMetricsHandler(jc jape.Context) {
+	metrics, err := s.e.BlockTimeMetrics()
+	if jc.Check("failed to get block time metrics", err) != nil {
+		return
+	}
+	jc.Encode(metrics)
+}
+
 func (s *server) blocksIDHandler(jc jape.Context) {
 	var id types.BlockID
 	if jc.DecodeParam("id", &id) != nil {
@@ -885,6 +894,7 @@ func NewServer(e Explorer, cm ChainManager, s Syncer, ex exchangerates.Source, a
 		"GET    /metrics/block":     srv.blocksMetricsHandler,
 		"GET    /metrics/block/:id": srv.blocksMetricsIDHandler,
 		"GET    /metrics/host":      srv.hostMetricsHandler,
+		"GET    /metrics/blocktime": srv.blockTimeMetricsHandler,
 
 		"POST   /hosts": srv.hostsHandler,
 

explorer/explorer.go

@@ -89,6 +89,7 @@ type Store interface {
 	Metrics(id types.BlockID) (Metrics, error)
 	LastSuccessScan() (time.Time, error)
 	HostMetrics() (HostMetrics, error)
+	BlockTimeMetrics(blockTime time.Duration) (BlockTimeMetrics, error)
 	Transactions(ids []types.TransactionID) ([]Transaction, error)
 	TransactionChainIndices(txid types.TransactionID, offset, limit uint64) ([]types.ChainIndex, error)
 	V2Transactions(ids []types.TransactionID) ([]V2Transaction, error)
@@ -319,6 +320,11 @@ func (e *Explorer) HostMetrics() (HostMetrics, error) {
 	return e.s.HostMetrics()
 }
 
+// BlockTimeMetrics returns the average block time during various intervals.
+func (e *Explorer) BlockTimeMetrics() (BlockTimeMetrics, error) {
+	return e.s.BlockTimeMetrics(e.cm.TipState().Network.BlockInterval)
+}
+
 // Transactions returns the transactions with the specified IDs.
 func (e *Explorer) Transactions(ids []types.TransactionID) ([]Transaction, error) {
 	return e.s.Transactions(ids)

explorer/types.go

@@ -605,3 +605,10 @@ type HostQuery struct {
 	AcceptContracts      *bool             `json:"acceptContracts,omitempty"`
 	Online               *bool             `json:"online,omitempty"`
 }
+
+// BlockTimeMetrics represents the average block time during various intervals.
+type BlockTimeMetrics struct {
+	Day   time.Duration
+	Week  time.Duration
+	Month time.Duration
+}

persist/sqlite/metrics.go

@@ -221,3 +221,53 @@ func (s *Store) HostMetrics() (result explorer.HostMetrics, err error) {
 	})
 	return
 }
+
+// BlockTimeMetrics implements explorer.Store.
+func (s *Store) BlockTimeMetrics(blockTime time.Duration) (result explorer.BlockTimeMetrics, err error) {
+	err = s.transaction(func(tx *txn) error {
+		const day = 24 * time.Hour
+		monthBlocks := int64(30*day) / int64(blockTime)
+
+		rows, err := tx.Query(`SELECT timestamp FROM blocks ORDER BY height DESC LIMIT ?`, monthBlocks)
+		if err != nil {
+			return fmt.Errorf("failed to query block timestamps: %w", err)
+		}
+		defer rows.Close()
+
+		timestamps := make([]time.Time, 0, monthBlocks)
+		for rows.Next() {
+			var timestamp time.Time
+			if err := rows.Scan(decode(&timestamp)); err != nil {
+				return fmt.Errorf("failed to scan block timestamp: %w", err)
+			}
+			timestamps = append(timestamps, timestamp)
+		}
+		if err := rows.Err(); err != nil {
+			return fmt.Errorf("failed to retrieve block timestamp rows: %w", err)
+		}
+
+		now := time.Now()
+		intervals := []time.Time{now.Add(-day), now.Add(-(7 * day)), now.Add(-(30 * day))}
+
+		sums := make([]time.Duration, len(intervals))
+		counts := make([]int64, len(intervals))
+		for i := range len(timestamps) - 1 {
+			timestamp := timestamps[i]
+			// descending order, so larger timestamps is first
+			delta := timestamps[i].Sub(timestamps[i+1])
+
+			for j, interval := range intervals {
+				if timestamp.After(interval) {
+					sums[j] += delta
+					counts[j]++
+				}
+			}
+		}
+		result.Day = sums[0] / time.Duration(max(1, counts[0]))
+		result.Week = sums[1] / time.Duration(max(1, counts[1]))
+		result.Month = sums[2] / time.Duration(max(1, counts[2]))
+
+		return nil
+	})
+	return
+}

persist/sqlite/metrics_test.go

@@ -2,12 +2,14 @@ package sqlite
 
 import (
 	"testing"
+	"time"
 
 	"go.sia.tech/core/consensus"
 	proto4 "go.sia.tech/core/rhp/v4"
 	"go.sia.tech/core/types"
 	"go.sia.tech/explored/explorer"
 	"go.sia.tech/explored/internal/testutil"
+	"lukechampine.com/frand"
 )
 
 func TestMetrics(t *testing.T) {
@@ -436,3 +438,52 @@ func TestV2Metrics(t *testing.T) {
 
 	assertMetrics(metricsGenesis)
 }
+
+func BenchmarkBlockTimeMetrics(b *testing.B) {
+	n := newTestChain(b, false, nil)
+
+	const month = 30 * 24 * time.Hour
+	const blockTime = 10 * time.Minute
+
+	now := time.Now().Add(-month)
+	err := n.db.transaction(func(tx *txn) error {
+		blockStmt, err := tx.Prepare(`INSERT INTO blocks(id, height, parent_id, nonce, timestamp, leaf_index) VALUES (?, ?, ?, ?, ?, ?)`)
+		if err != nil {
+			return err
+		}
+		defer blockStmt.Close()
+
+		var parentID types.BlockID
+		nonce, leafIndex := encode(uint64(0)), encode(uint64(0))
+		for i := range 500000 {
+			if i%10000 == 0 {
+				b.Log("Adding block:", i)
+			}
+			id := types.BlockID(frand.Entropy256())
+			if _, err := blockStmt.Exec(encode(id), i, encode(parentID), nonce, encode(now), leafIndex); err != nil {
+				b.Fatal(err)
+			}
+
+			parentID = id
+			now = now.Add(blockTime)
+		}
+		return nil
+	})
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	for b.Loop() {
+		blockTimes, err := n.db.BlockTimeMetrics(blockTime)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if blockTimes.Day != blockTime {
+			b.Fatalf("expected %v average block time for past day, got %v", blockTime, blockTimes.Day)
+		} else if blockTimes.Week != blockTime {
+			b.Fatalf("expected %v average block time for past week, got %v", blockTime, blockTimes.Week)
+		} else if blockTimes.Month != blockTime {
+			b.Fatalf("expected %v average block time for past month, got %v", blockTime, blockTimes.Month)
+		}
+	}
+}