Merge pull request #7227 from multiversx/termui-new-metrics

MX-17032 Termui update - added metrics

Author: sstanculeanu

cmd/termui/presenter/blockInfoGetters.go

@@ -56,3 +56,23 @@ func (psh *PresenterStatusHandler) GetBlockSize() uint64 {
 func (psh *PresenterStatusHandler) GetHighestFinalBlock() uint64 {
 	return psh.getFromCacheAsUint64(common.MetricHighestFinalBlock)
 }
+
+// GetDurationProposedBlockReceivedOrSentFromRoundStart returns the metrics containing time taken to receive a proposed block body since the round started
+func (psh *PresenterStatusHandler) GetDurationProposedBlockReceivedOrSentFromRoundStart() uint64 {
+	return psh.getFromCacheAsUint64(common.MetricReceivedOrSentProposedBlock)
+}
+
+// GetDurationProofReceivedFromProposedBlockReceivedOrSent returns the metrics containing time taken to receive signatures for a block since the block was received
+func (psh *PresenterStatusHandler) GetDurationProofReceivedFromProposedBlockReceivedOrSent() uint64 {
+	return psh.getFromCacheAsUint64(common.MetricReceivedProof)
+}
+
+// GetAvgDurationProposedBlockReceivedOrSentFromRoundStart returns the average received proposed block body metric
+func (psh *PresenterStatusHandler) GetAvgDurationProposedBlockReceivedOrSentFromRoundStart() uint64 {
+	return psh.getFromCacheAsUint64(common.MetricAvgReceivedOrSentProposedBlock)
+}
+
+// GetAvgDurationProofReceivedFromProposedBlockReceivedOrSent returns the average received signatures metric from the time of block body received
+func (psh *PresenterStatusHandler) GetAvgDurationProofReceivedFromProposedBlockReceivedOrSent() uint64 {
+	return psh.getFromCacheAsUint64(common.MetricAvgReceivedProof)
+}

cmd/termui/presenter/blockInfoGetters_test.go

@@ -125,18 +125,47 @@ func TestPresenterStatusHandler_GetCurrentRoundTimestamp(t *testing.T) {
 	assert.Equal(t, currentRoundTimestamp, result)
 }
 
-func TestPresenterStatusHandler_GetBlockSize(t *testing.T) {
+func TestPresenterStatusHandler_GetBlockReceived(t *testing.T) {
 	t.Parallel()
 
-	miniBlocksSize := uint64(100)
-	headerSize := uint64(50)
+	proposedBlockMs := uint64(100)
+
 	presenterStatusHandler := NewPresenterStatusHandler()
-	presenterStatusHandler.SetUInt64Value(common.MetricMiniBlocksSize, miniBlocksSize)
-	presenterStatusHandler.SetUInt64Value(common.MetricHeaderSize, headerSize)
-	result := presenterStatusHandler.GetBlockSize()
+	presenterStatusHandler.SetUInt64Value(common.MetricReceivedOrSentProposedBlock, proposedBlockMs)
+	result := presenterStatusHandler.GetDurationProposedBlockReceivedOrSentFromRoundStart()
+	assert.Equal(t, proposedBlockMs, result)
+}
 
-	blockExpectedSize := miniBlocksSize + headerSize
-	assert.Equal(t, blockExpectedSize, result)
+func TestPresenterStatusHandler_GetAvgBlockReceived(t *testing.T) {
+	t.Parallel()
+
+	proposedBlockMs := uint64(100)
+
+	presenterStatusHandler := NewPresenterStatusHandler()
+	presenterStatusHandler.SetUInt64Value(common.MetricAvgReceivedOrSentProposedBlock, proposedBlockMs)
+	result := presenterStatusHandler.GetAvgDurationProposedBlockReceivedOrSentFromRoundStart()
+	assert.Equal(t, proposedBlockMs, result)
+}
+
+func TestPresenterStatusHandler_GetProofReceived(t *testing.T) {
+	t.Parallel()
+
+	proofMs := uint64(100)
+
+	presenterStatusHandler := NewPresenterStatusHandler()
+	presenterStatusHandler.SetUInt64Value(common.MetricReceivedProof, proofMs)
+	result := presenterStatusHandler.GetDurationProofReceivedFromProposedBlockReceivedOrSent()
+	assert.Equal(t, proofMs, result)
+}
+func TestPresenterStatusHandler_GetAvgProofReceived(t *testing.T) {
+	t.Parallel()
+
+	proofMs := uint64(100)
+
+	presenterStatusHandler := NewPresenterStatusHandler()
+	presenterStatusHandler.SetUInt64Value(common.MetricAvgReceivedProof, proofMs)
+	result := presenterStatusHandler.GetAvgDurationProofReceivedFromProposedBlockReceivedOrSent()
+	assert.Equal(t, proofMs, result)
 }
 
 func TestPresenterStatusHandler_GetHighestFinalBlock(t *testing.T) {
@@ -149,3 +178,17 @@ func TestPresenterStatusHandler_GetHighestFinalBlock(t *testing.T) {
 
 	assert.Equal(t, highestFinalBlockNonce, result)
 }
+
+func TestPresenterStatusHandler_GetBlockSize(t *testing.T) {
+	t.Parallel()
+
+	miniBlocksSize := uint64(100)
+	headerSize := uint64(50)
+	presenterStatusHandler := NewPresenterStatusHandler()
+	presenterStatusHandler.SetUInt64Value(common.MetricMiniBlocksSize, miniBlocksSize)
+	presenterStatusHandler.SetUInt64Value(common.MetricHeaderSize, headerSize)
+	result := presenterStatusHandler.GetBlockSize()
+
+	blockExpectedSize := miniBlocksSize + headerSize
+	assert.Equal(t, blockExpectedSize, result)
+}

cmd/termui/provider/logProvider.go

@@ -11,7 +11,7 @@ import (
 	"github.com/multiversx/mx-chain-core-go/marshal"
 	"github.com/multiversx/mx-chain-go/common"
 	"github.com/multiversx/mx-chain-go/node"
-	"github.com/multiversx/mx-chain-logger-go"
+	logger "github.com/multiversx/mx-chain-logger-go"
 )
 
 var formatter = logger.PlainFormatter{}
@@ -48,14 +48,18 @@ func InitLogHandler(args LogHandlerArgs) error {
 
 	var err error
 	scheme := ws
+
 	if args.UseWss {
 		scheme = wss
 	}
+	nodeURL := getNodeUrlPath(args.NodeURL)
+
 	go func() {
 		for {
-			webSocket, err = openWebSocket(scheme, args.NodeURL)
+			webSocket, err = openWebSocket(scheme, nodeURL)
+
 			if err != nil {
-				_, _ = args.Presenter.Write([]byte(fmt.Sprintf("termui websocket error, retrying in %v...", retryDuration)))
+				_, _ = args.Presenter.Write([]byte(fmt.Sprintf("termui websocket error %s, retrying in %v...", err, retryDuration)))
 				time.Sleep(retryDuration)
 				continue
 			}
@@ -75,12 +79,17 @@ func InitLogHandler(args LogHandlerArgs) error {
 	return nil
 }
 
+func getNodeUrlPath(nodeURL string) string {
+	return strings.TrimPrefix(strings.TrimPrefix(nodeURL, "http://"), "https://")
+}
+
 func openWebSocket(scheme string, address string) (*websocket.Conn, error) {
 	u := url.URL{
 		Scheme: scheme,
 		Host:   address,
 		Path:   "/log",
 	}
+
 	conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
 	if err != nil {
 		return nil, err

cmd/termui/view/interface.go

@@ -18,6 +18,10 @@ type Presenter interface {
 	GetCountConsensusAcceptedBlocks() uint64
 	GetCountLeader() uint64
 	GetCountAcceptedBlocks() uint64
+	GetDurationProposedBlockReceivedOrSentFromRoundStart() uint64
+	GetDurationProofReceivedFromProposedBlockReceivedOrSent() uint64
+	GetAvgDurationProposedBlockReceivedOrSentFromRoundStart() uint64
+	GetAvgDurationProofReceivedFromProposedBlockReceivedOrSent() uint64
 	GetIsSyncing() uint64
 	GetTxPoolLoad() uint64
 	GetNonce() uint64

cmd/termui/view/termuic/termuiRenders/drawableContainer.go

@@ -4,7 +4,7 @@ import (
 	"github.com/gizak/termui/v3"
 )
 
-const topHeight = 22
+const topHeight = 24
 
 // DrawableContainer defines a container of drawable object with position and dimensions
 type DrawableContainer struct {

cmd/termui/view/termuic/termuiRenders/widgetsRender.go

@@ -11,6 +11,8 @@ import (
 	"github.com/multiversx/mx-chain-go/common"
 )
 
+const conversionFactorToSeconds = 1e9
+
 const (
 	statusSyncing       = "currently syncing"
 	statusSynchronized  = "synchronized"
@@ -90,12 +92,15 @@ func (wr *WidgetsRender) setGrid() {
 	colMemoryLoad := ui.NewCol(1.0/2, wr.memoryLoad)
 
 	gridRight := ui.NewGrid()
+
+	progressBarElementRatio := 3.0 / topHeight
+	blockSectionHeightRatio := 1 - 4*progressBarElementRatio
 	gridRight.Set(
-		ui.NewRow(10.0/22, wr.blockInfo),
-		ui.NewRow(3.0/22, colCpuLoad, colMemoryLoad),
-		ui.NewRow(3.0/22, wr.epochLoad),
-		ui.NewRow(3.0/22, wr.networkBytesInEpoch),
-		ui.NewRow(3.0/22, colNetworkSent, colNetworkRecv),
+		ui.NewRow(blockSectionHeightRatio, wr.blockInfo),
+		ui.NewRow(progressBarElementRatio, colCpuLoad, colMemoryLoad),
+		ui.NewRow(progressBarElementRatio, wr.epochLoad),
+		ui.NewRow(progressBarElementRatio, wr.networkBytesInEpoch),
+		ui.NewRow(progressBarElementRatio, colNetworkSent, colNetworkRecv),
 	)
 
 	gridBottom := ui.NewGrid()
@@ -294,51 +299,70 @@ func computeRedundancyStr(redundancyLevel int64, redundancyIsMainActive string)
 }
 
 func (wr *WidgetsRender) prepareBlockInfo() {
-	// 7 rows and one column
-	numRows := 8
+	// 8 rows and one column
+	numRows := 9
 	rows := make([][]string, numRows)
 
 	currentBlockHeight := wr.presenter.GetNonce()
 	blockSize := wr.presenter.GetBlockSize()
 	rows[0] = []string{fmt.Sprintf("Current block height: %d, size: %s", currentBlockHeight, core.ConvertBytes(blockSize))}
 
 	numTransactionInBlock := wr.presenter.GetNumTxInBlock()
-	rows[1] = []string{fmt.Sprintf("Num transactions in block: %d", numTransactionInBlock)}
-
 	numMiniBlocks := wr.presenter.GetNumMiniBlocks()
-	rows[2] = []string{fmt.Sprintf("Num miniblocks in block: %d", numMiniBlocks)}
+	rows[1] = []string{fmt.Sprintf("Num transactions in block: %d | Num miniblocks in block: %d",
+		numTransactionInBlock,
+		numMiniBlocks,
+	)}
 
 	currentBlockHash := wr.presenter.GetCurrentBlockHash()
-	rows[3] = []string{fmt.Sprintf("Current block hash: %s", currentBlockHash)}
+	rows[2] = []string{fmt.Sprintf("Current block hash: %s", currentBlockHash)}
 
 	crossCheckBlockHeight := wr.presenter.GetCrossCheckBlockHeight()
-	rows[4] = []string{fmt.Sprintf("Cross check: %s", crossCheckBlockHeight)}
+	rows[3] = []string{fmt.Sprintf("Cross check: %s", crossCheckBlockHeight)}
 
 	shardId := wr.presenter.GetShardId()
 	if shardId != uint64(core.MetachainShardId) {
 		highestFinalBlock := wr.presenter.GetHighestFinalBlock()
-		rows[4][0] += fmt.Sprintf(", final nonce: %d", highestFinalBlock)
+		rows[3][0] += fmt.Sprintf(", final nonce: %d", highestFinalBlock)
 	}
 
 	consensusState := wr.presenter.GetConsensusState()
-	rows[5] = []string{fmt.Sprintf("Consensus state: %s", consensusState)}
+	rows[4] = []string{fmt.Sprintf("Consensus state: %s", consensusState)}
 
 	syncStatus := wr.presenter.GetIsSyncing()
 	switch syncStatus {
 	case 1:
-		rows[6] = []string{"Consensus round state: N/A (syncing)"}
+		rows[5] = []string{"Consensus round state: N/A (syncing)"}
 	case 0:
 		instanceType := wr.presenter.GetNodeType()
 		if instanceType == string(core.NodeTypeObserver) {
-			rows[6] = []string{fmt.Sprintf("Consensus round state: N/A (%s)", string(core.NodeTypeObserver))}
+			rows[5] = []string{fmt.Sprintf("Consensus round state: N/A (%s)", string(core.NodeTypeObserver))}
 		} else {
 			consensusRoundState := wr.presenter.GetConsensusRoundState()
-			rows[6] = []string{fmt.Sprintf("Consensus round state: %s", consensusRoundState)}
+			rows[5] = []string{fmt.Sprintf("Consensus round state: %s", consensusRoundState)}
 		}
 	}
 
 	currentRoundTimestamp := wr.presenter.GetCurrentRoundTimestamp()
-	rows[7] = []string{fmt.Sprintf("Current round timestamp: %d", currentRoundTimestamp)}
+	rows[8] = []string{fmt.Sprintf("Current round timestamp: %d", currentRoundTimestamp)}
+
+	durationStartRoundToSentOrReceivedBlock := float64(wr.presenter.GetDurationProposedBlockReceivedOrSentFromRoundStart()) / conversionFactorToSeconds
+	durationSentOrReceivedBlockToReceivedSignatures := float64(wr.presenter.GetDurationProofReceivedFromProposedBlockReceivedOrSent()) / conversionFactorToSeconds
+
+	rows[6] = []string{
+		fmt.Sprintf("Received proposed block: %.6f sec | Received signatures: %.6f sec",
+			durationStartRoundToSentOrReceivedBlock,
+			durationSentOrReceivedBlockToReceivedSignatures),
+	}
+
+	durationStartRoundToSentOrReceivedBlock = float64(wr.presenter.GetAvgDurationProposedBlockReceivedOrSentFromRoundStart()) / conversionFactorToSeconds
+	durationSentOrReceivedBlockToReceivedSignatures = float64(wr.presenter.GetAvgDurationProofReceivedFromProposedBlockReceivedOrSent()) / conversionFactorToSeconds
+
+	rows[7] = []string{
+		fmt.Sprintf("Avg Received proposed block: %.6f sec | Avg Received signatures: %.6f sec",
+			durationStartRoundToSentOrReceivedBlock,
+			durationSentOrReceivedBlockToReceivedSignatures),
+	}
 
 	wr.blockInfo.Title = "Block info:"
 	wr.blockInfo.RowSeparator = false

cmd/termui/view/termuic/termuiRenders/widgetsRender_test.go

@@ -4,7 +4,11 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/gizak/termui/v3/widgets"
+	"github.com/multiversx/mx-chain-go/cmd/termui/presenter"
+	"github.com/multiversx/mx-chain-go/common"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestWidgetsRender_prepareLogLines(t *testing.T) {
@@ -43,3 +47,46 @@ func TestWidgetsRender_prepareLogLines(t *testing.T) {
 		assert.Equal(t, 8, len(result))
 	})
 }
+
+func TestPrepareBlockInfo(t *testing.T) {
+	presenterStatusHandler := presenter.NewPresenterStatusHandler()
+	presenterStatusHandler.SetUInt64Value(common.MetricNonce, 42)
+	presenterStatusHandler.SetUInt64Value(common.MetricMiniBlocksSize, 2000)
+	presenterStatusHandler.SetUInt64Value(common.MetricHeaderSize, 48)
+	presenterStatusHandler.SetUInt64Value(common.MetricNumTxInBlock, 5)
+	presenterStatusHandler.SetUInt64Value(common.MetricNumMiniBlocks, 2)
+	presenterStatusHandler.SetStringValue(common.MetricCurrentBlockHash, "hash")
+	presenterStatusHandler.SetStringValue(common.MetricCrossCheckBlockHeight, "cross123")
+	presenterStatusHandler.SetUInt64Value(common.MetricHighestFinalBlock, 99)
+	presenterStatusHandler.SetUInt64Value(common.MetricShardId, 0) // not metachain
+	presenterStatusHandler.SetStringValue(common.MetricConsensusState, "ProposedBlock")
+	presenterStatusHandler.SetUInt64Value(common.MetricIsSyncing, 0)
+	presenterStatusHandler.SetStringValue(common.MetricConsensusRoundState, "Success")
+	presenterStatusHandler.SetUInt64Value(common.MetricCurrentRoundTimestamp, 123456)
+	presenterStatusHandler.SetUInt64Value(common.MetricReceivedOrSentProposedBlock, 2_000_000) // ns
+	presenterStatusHandler.SetUInt64Value(common.MetricReceivedProof, 3_000_000)
+	presenterStatusHandler.SetUInt64Value(common.MetricAvgReceivedOrSentProposedBlock, 1_000_000)
+	presenterStatusHandler.SetUInt64Value(common.MetricAvgReceivedProof, 1_500_000)
+
+	wr := &WidgetsRender{
+		presenter: presenterStatusHandler,
+		blockInfo: &widgets.Table{},
+	}
+
+	wr.prepareBlockInfo()
+
+	require.Equal(t, "Block info:", wr.blockInfo.Title)
+	require.False(t, wr.blockInfo.RowSeparator)
+	require.Len(t, wr.blockInfo.Rows, 9)
+
+	// Example: check one row
+	require.Contains(t, wr.blockInfo.Rows[0][0], fmt.Sprintf("Current block height: %d, size: %s", 42, "2.00 KB"))
+	require.Contains(t, wr.blockInfo.Rows[2][0], "hash")
+	require.Contains(t, wr.blockInfo.Rows[4][0], "Consensus state: ProposedBlock")
+	require.Contains(t, wr.blockInfo.Rows[5][0], "Consensus round state: Success")
+	require.Contains(t, wr.blockInfo.Rows[6][0], "Received proposed block: 0.002000 sec | Received signatures: 0.003000 sec")
+	require.Contains(t, wr.blockInfo.Rows[7][0], "Avg Received proposed block: 0.001000 sec | Avg Received signatures: 0.001500 sec")
+	require.Contains(t, wr.blockInfo.Rows[8][0], "Current round timestamp: 123456")
+	require.Contains(t, wr.blockInfo.Rows[3][0], "Cross check: cross123, final nonce: 99")
+
+}

common/constants.go

@@ -315,6 +315,22 @@ const MetricNoncesPassedInCurrentEpoch = "erd_nonces_passed_in_current_epoch"
 // 100 meaning that the block has been received in the last moment of the round)
 const MetricReceivedProposedBlock = "erd_consensus_received_proposed_block"
 
+// MetricReceivedOrSentProposedBlock is the metric that specifies the delay in nanoseconds from the start of the current round until
+// the time the proposed block body has been sent or has reached the current node.
+const MetricReceivedOrSentProposedBlock = "erd_consensus_received_or_sent_proposed_block"
+
+// MetricReceivedProof is the metric that specifies the delay in nanoseconds between the time the proposed block has been sent
+// or has reached the current node until the proof was received.
+const MetricReceivedProof = "erd_consensus_received_proof"
+
+// MetricAvgReceivedOrSentProposedBlock is the metric that specifies the average delay in nanoseconds from the start of the round until
+// the time the proposed block has been sent or has reached the current node.
+const MetricAvgReceivedOrSentProposedBlock = "erd_consensus_average_received_or_sent_proposed_block"
+
+// MetricAvgReceivedProof is the metric that specifies the average delay in nanoseconds between the time the proposed block
+// has been sent or has reached the current node until proof was received.
+const MetricAvgReceivedProof = "erd_consensus_average_received_sent_proof"
+
 // MetricCreatedProposedBlock is the metric that specifies the percent of the block subround used for header and body
 // creation (0 meaning that the block was created in no-time and 100 meaning that the block creation used all the
 // subround spare duration)

consensus/interface.go

@@ -212,6 +212,7 @@ type EquivalentProofsPool interface {
 	GetProof(shardID uint32, headerHash []byte) (data.HeaderProofHandler, error)
 	GetProofByNonce(headerNonce uint64, shardID uint32) (data.HeaderProofHandler, error)
 	HasProof(shardID uint32, headerHash []byte) bool
+	RegisterHandler(handler func(headerProof data.HeaderProofHandler))
 	IsInterfaceNil() bool
 }
 

consensus/spos/bls/v2/export_test.go

@@ -226,6 +226,11 @@ func (sr *subroundBlock) GetLeaderForHeader(headerHandler data.HeaderHandler) ([
 	return sr.getLeaderForHeader(headerHandler)
 }
 
+// UpdateConsensusMetricsProposedBlockReceivedOrSent updates the metrics containing time taken to receive a proposed block body since the round started
+func (sr *subroundBlock) UpdateConsensusMetricsProposedBlockReceivedOrSent() {
+	sr.updateConsensusMetricsProposedBlockReceivedOrSent()
+}
+
 // subroundSignature
 
 // SubroundSignature defines an alias to the subroundSignature structure
@@ -360,3 +365,8 @@ func (sr *subroundEndRound) GetEquivalentProofSender() string {
 func (sr *subroundEndRound) SendProof() (bool, error) {
 	return sr.sendProof()
 }
+
+// UpdateConsensusMetricsProof -
+func (sr *subroundEndRound) UpdateConsensusMetricsProof() {
+	sr.updateConsensusMetricsProof()
+}