Merge pull request #7 from algorandfoundation/feat/round-time-tps

feat: TPS and average round times

Author: PhearZero

internal/block.go

@@ -0,0 +1,63 @@
+package internal
+
+import (
+	"context"
+	"errors"
+	"github.com/algorandfoundation/hack-tui/api"
+	"time"
+)
+
+func GetBlock(ctx context.Context, client *api.ClientWithResponses, round uint64) (map[string]interface{}, error) {
+
+	var format api.GetBlockParamsFormat = "json"
+	block, err := client.GetBlockWithResponse(ctx, int(round), &api.GetBlockParams{
+		Format: &format,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if block.StatusCode() != 200 {
+		return nil, errors.New("invalid status code")
+	}
+
+	return block.JSON200.Block, nil
+}
+
+type BlockMetrics struct {
+	AvgTime time.Duration
+	TPS     float64
+}
+
+func GetBlockMetrics(ctx context.Context, client *api.ClientWithResponses, round uint64, window int) (*BlockMetrics, error) {
+	var avgs BlockMetrics
+	if round < uint64(window) {
+		avgs.AvgTime = 0
+		avgs.TPS = 0
+		return &avgs, nil
+	}
+	var format api.GetBlockParamsFormat = "json"
+	a, err := client.GetBlockWithResponse(ctx, int(round), &api.GetBlockParams{
+		Format: &format,
+	})
+	if err != nil {
+		return nil, err
+	}
+	b, err := client.GetBlockWithResponse(ctx, int(round)-window, &api.GetBlockParams{
+		Format: &format,
+	})
+	if err != nil {
+		return nil, err
+	}
+	// Push to the transactions count list
+	aTimestamp := time.Duration(a.JSON200.Block["ts"].(float64)) * time.Second
+	bTimestamp := time.Duration(b.JSON200.Block["ts"].(float64)) * time.Second
+	//
+	aTransactions := a.JSON200.Block["tc"].(float64)
+	bTransactions := b.JSON200.Block["tc"].(float64)
+
+	avgs.AvgTime = time.Duration((int(aTimestamp - bTimestamp)) / window)
+	avgs.TPS = (aTransactions - bTransactions) / (float64(window) * avgs.AvgTime.Seconds())
+
+	return &avgs, nil
+}

internal/block_test.go

@@ -0,0 +1,31 @@
+package internal
+
+import (
+	"context"
+	"github.com/algorandfoundation/hack-tui/api"
+	"testing"
+	"time"
+)
+
+func Test_GetBlockMetrics(t *testing.T) {
+	window := 1000000
+
+	expectedAvg := time.Duration(2856041000)
+
+	client, err := api.NewClientWithResponses("https://mainnet-api.4160.nodely.dev:443")
+
+	metrics, err := GetBlockMetrics(context.Background(), client, uint64(42000000), window)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if metrics.AvgTime != expectedAvg {
+		t.Fatal("expected time to be", expectedAvg, "got", metrics.AvgTime)
+	}
+
+	expectedTPS := 25.318608871511294
+
+	if metrics.TPS != expectedTPS {
+		t.Fatal("expected tps to be", expectedTPS, "got", metrics.TPS)
+	}
+}

internal/state.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"github.com/algorandfoundation/hack-tui/api"
-	"time"
 )
 
 type StateModel struct {
@@ -17,25 +16,12 @@ type StateModel struct {
 	Watching bool
 }
 
-func getAverage(data []float64) float64 {
-	sum := 0.0
-	for _, element := range data {
-		sum += element
-	}
-	return sum / (float64(len(data)))
-}
-func getAverageDuration(timings []time.Duration) time.Duration {
-	sum := 0.0
-	for _, element := range timings {
-		sum += element.Seconds()
-	}
-	avg := sum / (float64(len(timings)))
-	return time.Duration(avg * float64(time.Second))
-}
-
 // TODO: allow context to handle loop
 func (s *StateModel) Watch(cb func(model *StateModel, err error), ctx context.Context, client *api.ClientWithResponses) {
 	s.Watching = true
+	if s.Metrics.Window == 0 {
+		s.Metrics.Window = 100
+	}
 
 	err := s.Status.Fetch(ctx, client)
 	if err != nil {
@@ -44,61 +30,33 @@ func (s *StateModel) Watch(cb func(model *StateModel, err error), ctx context.Co
 
 	lastRound := s.Status.LastRound
 
-	// Collection of Round Durations
-	timings := make([]time.Duration, 0)
-	// Collection of Transaction Counts
-	txns := make([]float64, 0)
-
 	for {
 		if !s.Watching {
 			break
 		}
-		// Collect Time of Round
-		startTime := time.Now()
 		status, err := client.WaitForBlockWithResponse(ctx, int(lastRound))
 		if err != nil {
 			cb(nil, err)
 		}
 		if status.StatusCode() != 200 {
 			cb(nil, errors.New(status.Status()))
 		}
-		// Store round timing
-		endTime := time.Now()
-		dur := endTime.Sub(startTime)
-		timings = append(timings, dur)
 
 		// Update Status
 		s.Status.LastRound = uint64(status.JSON200.LastRound)
 
 		// Fetch Keys
 		s.UpdateKeys(ctx, client)
 
-		// Fetch Block
-		var format api.GetBlockParamsFormat = "json"
-		block, err := client.GetBlockWithResponse(ctx, int(lastRound), &api.GetBlockParams{
-			Format: &format,
-		})
-		if err != nil {
-			cb(nil, err)
-		}
-
-		// Check for transactions
-		if block.JSON200.Block["txns"] != nil {
-			// Get the average duration in seconds (TPS)
-			txnCount := float64(len(block.JSON200.Block["txns"].([]any)))
-			txns = append(txns, txnCount/getAverageDuration(timings).Seconds())
-		} else {
-			txns = append(txns, 0)
-		}
-
-		// Fetch RX/TX every 5th round
+		// Run Round Averages and RX/TX every 5 rounds
 		if s.Status.LastRound%5 == 0 {
-			s.UpdateMetrics(ctx, client, timings, txns)
-		}
-		// Trim data
-		if len(timings) >= 100 {
-			timings = timings[1:]
-			txns = txns[1:]
+			bm, err := GetBlockMetrics(ctx, client, s.Status.LastRound, s.Metrics.Window)
+			if err != nil {
+				cb(nil, err)
+			}
+			s.Metrics.RoundTime = bm.AvgTime
+			s.Metrics.TPS = bm.TPS
+			s.UpdateMetricsFromRPC(ctx, client)
 		}
 
 		lastRound = s.Status.LastRound
@@ -110,20 +68,7 @@ func (s *StateModel) Stop() {
 	s.Watching = false
 }
 
-func (s *StateModel) UpdateMetrics(
-	ctx context.Context,
-	client *api.ClientWithResponses,
-	timings []time.Duration,
-	txns []float64,
-) {
-	if s == nil {
-		panic("StateModel is nil while UpdateMetrics is called")
-	}
-	// Set Metrics
-	s.Metrics.RoundTime = getAverageDuration(timings)
-	s.Metrics.Window = len(timings)
-	s.Metrics.TPS = getAverage(txns)
-
+func (s *StateModel) UpdateMetricsFromRPC(ctx context.Context, client *api.ClientWithResponses) {
 	// Fetch RX/TX
 	res, err := GetMetrics(ctx, client)
 	if err != nil {
@@ -135,7 +80,6 @@ func (s *StateModel) UpdateMetrics(
 		s.Metrics.RX = res["algod_network_received_bytes_total"]
 	}
 }
-
 func (s *StateModel) UpdateAccounts() {
 	s.Accounts = AccountsFromState(s)
 }

internal/status.go

@@ -8,7 +8,6 @@ import (
 
 // StatusModel represents a status response from algod.Status
 type StatusModel struct {
-	Metrics     MetricsModel
 	State       string
 	Version     string
 	Network     string
@@ -19,7 +18,7 @@ type StatusModel struct {
 
 // String prints the last round value
 func (m *StatusModel) String() string {
-	return fmt.Sprintf("\nLastRound: %d\nRoundTime: %f \nTPS: %f", m.LastRound, m.Metrics.RoundTime.Seconds(), m.Metrics.TPS)
+	return fmt.Sprintf("\nLastRound: %d\n", m.LastRound)
 }
 
 // Fetch handles algod.Status