Update initial facade metrics

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

@@ -120,13 +120,36 @@ func (wr *WidgetsRender) RefreshData(numMillisecondsRefreshTime int) {
 	wr.prepareLoads()
 }
 
+func (wr *WidgetsRender) getShardIdStr() string {
+	currentRound := wr.presenter.GetCurrentRound()
+	nodesProcessed := wr.presenter.GetTrieSyncNumProcessedNodes()
+	isNodeSyncingTrie := nodesProcessed != 0
+
+	synchronizedRound := wr.presenter.GetSynchronizedRound()
+	isRoundNotSynchronized := synchronizedRound < currentRound
+
+	isNodeSyncing := isNodeSyncingTrie || isRoundNotSynchronized || currentRound == 0
+
+	if isNodeSyncing {
+		return statusNotApplicable
+	}
+
+	shardID := wr.presenter.GetShardId()
+
+	shardIdStr := fmt.Sprintf("%d", shardID)
+	if shardID == uint64(core.MetachainShardId) {
+		shardIdStr = "meta"
+	}
+
+	return shardIdStr
+}
+
 func (wr *WidgetsRender) prepareInstanceInfo() {
 	// 8 rows and one column
 	numRows := 8
 	rows := make([][]string, numRows)
 
 	nodeName := wr.presenter.GetNodeName()
-	shardId := wr.presenter.GetShardId()
 	instanceType := wr.presenter.GetNodeType()
 	peerType := wr.presenter.GetPeerType()
 	peerSubType := wr.presenter.GetPeerSubType()
@@ -139,15 +162,12 @@ func (wr *WidgetsRender) prepareInstanceInfo() {
 	if peerSubType == core.FullHistoryObserver.String() {
 		nodeTypeAndListDisplay += " - full archive"
 	}
-	shardIdStr := fmt.Sprintf("%d", shardId)
-	if shardId == uint64(core.MetachainShardId) {
-		shardIdStr = "meta"
-	}
+
 	wr.instanceInfo.RowStyles[0] = ui.NewStyle(ui.ColorYellow)
 	rows[0] = []string{
 		fmt.Sprintf("Node name: %s (Shard %s - %s)",
 			nodeName,
-			shardIdStr,
+			wr.getShardIdStr(),
 			nodeTypeAndListDisplay,
 		),
 	}

facade/initial/initialStatusMetricsProvider.go

@@ -26,9 +26,9 @@ func (provider *initialStatusMetricsProvider) BootstrapMetrics() (map[string]int
 	return provider.realStatusMetricsProvider.BootstrapMetrics()
 }
 
-// StatusMetricsMapWithoutP2P returns an empty map and the error which specifies that the node is starting
+// StatusMetricsMapWithoutP2P returns the status metrics (excluding P2P-related ones)
 func (provider *initialStatusMetricsProvider) StatusMetricsMapWithoutP2P() (map[string]interface{}, error) {
-	return getEmptyReturnValues()
+	return provider.realStatusMetricsProvider.StatusMetricsMapWithoutP2P()
 }
 
 // StatusP2pMetricsMap returns an empty map and the error which specifies that the node is starting

facade/initial/initialStatusMetricsProvider_test.go

@@ -34,16 +34,24 @@ func TestNewInitialStatusMetricsProvider(t *testing.T) {
 			"key-2": uint64(15),
 			"key-3": uint64(20),
 		}
+
+		providedMetrics2 := map[string]interface{}{
+			"key-11": uint64(20),
+			"key-21": uint64(25),
+			"key-31": uint64(30),
+		}
 		statusMetricsProvider := &testscommon.StatusMetricsStub{
 			BootstrapMetricsCalled: func() (map[string]interface{}, error) {
 				return providedMetrics, nil
 			},
+			StatusMetricsMapWithoutP2PCalled: func() (map[string]interface{}, error) {
+				return providedMetrics2, nil
+			},
 		}
 		provider, err := NewInitialStatusMetricsProvider(statusMetricsProvider)
 		assert.Nil(t, err)
 		assert.False(t, check.IfNil(provider))
 
-		testDisabledGetter(t, provider.StatusMetricsMapWithoutP2P)
 		testDisabledGetter(t, provider.StatusP2pMetricsMap)
 		testDisabledGetter(t, provider.EconomicsMetrics)
 		testDisabledGetter(t, provider.ConfigMetrics)
@@ -61,6 +69,10 @@ func TestNewInitialStatusMetricsProvider(t *testing.T) {
 		bootstrapMetrics, err := provider.BootstrapMetrics()
 		assert.Nil(t, err)
 		assert.Equal(t, providedMetrics, bootstrapMetrics)
+
+		statusMetrics, err := provider.StatusMetricsMapWithoutP2P()
+		assert.Nil(t, err)
+		assert.Equal(t, providedMetrics2, statusMetrics)
 	})
 }
 

node/metrics/metrics.go

@@ -275,6 +275,53 @@ func InitRatingsMetrics(appStatusHandler core.AppStatusHandler, ratingsConfig co
 	return nil
 }
 
+// InitInitialMetrics will set initial metrics for status handler (before bootstrapping process is completed)
+func InitInitialMetrics(
+	appStatusHandler core.AppStatusHandler,
+	pubkeyStr string,
+	nodesConfig sharding.GenesisNodesSetupHandler,
+	version string,
+	economicsConfig *config.EconomicsConfig,
+	minTransactionVersion uint32,
+) error {
+	if check.IfNil(appStatusHandler) {
+		return ErrNilAppStatusHandler
+	}
+	if nodesConfig == nil {
+		return fmt.Errorf("nil nodes config when initializing metrics")
+	}
+	if economicsConfig == nil {
+		return fmt.Errorf("nil economics config when initializing metrics")
+	}
+
+	isSyncing := uint64(1)
+
+	leaderPercentage := float64(0)
+	rewardsConfigs := make([]config.EpochRewardSettings, len(economicsConfig.RewardsSettings.RewardsConfigByEpoch))
+	_ = copy(rewardsConfigs, economicsConfig.RewardsSettings.RewardsConfigByEpoch)
+
+	sort.Slice(rewardsConfigs, func(i, j int) bool {
+		return rewardsConfigs[i].EpochEnable < rewardsConfigs[j].EpochEnable
+	})
+
+	if len(rewardsConfigs) > 0 {
+		leaderPercentage = rewardsConfigs[0].LeaderPercentage
+	}
+
+	appStatusHandler.SetStringValue(common.MetricPublicKeyBlockSign, pubkeyStr)
+	appStatusHandler.SetStringValue(common.MetricAppVersion, version)
+	appStatusHandler.SetStringValue(common.MetricCrossCheckBlockHeight, "N/A")
+	appStatusHandler.SetUInt64Value(common.MetricCrossCheckBlockHeightMeta, 0)
+	appStatusHandler.SetUInt64Value(common.MetricIsSyncing, isSyncing)
+	appStatusHandler.SetStringValue(common.MetricLeaderPercentage, fmt.Sprintf("%f", leaderPercentage))
+	appStatusHandler.SetUInt64Value(common.MetricDenomination, uint64(economicsConfig.GlobalSettings.Denomination))
+
+	appStatusHandler.SetUInt64Value(common.MetricStartTime, uint64(nodesConfig.GetStartTime()))
+	appStatusHandler.SetUInt64Value(common.MetricMinTransactionVersion, uint64(minTransactionVersion))
+
+	return nil
+}
+
 // InitMetrics will init metrics for status handler
 func InitMetrics(
 	appStatusHandler core.AppStatusHandler,

node/nodeRunner.go

@@ -318,6 +318,12 @@ func (nr *nodeRunner) executeOneComponentCreationCycle(
 		return true, err
 	}
 
+	log.Debug("creating metrics before bootstrap")
+	err = nr.createMetricsBeforeBootrapping(managedStatusCoreComponents, managedCoreComponents, managedCryptoComponents)
+	if err != nil {
+		return true, err
+	}
+
 	log.Debug("creating disabled API services")
 	webServerHandler, err := nr.createHttpServer(managedStatusCoreComponents)
 	if err != nil {
@@ -828,34 +834,32 @@ func (nr *nodeRunner) createHttpServer(managedStatusCoreComponents mainFactory.S
 	return httpServerWrapper, nil
 }
 
-func (nr *nodeRunner) createMetrics(
+func (nr *nodeRunner) createMetricsBeforeBootrapping(
 	statusCoreComponents mainFactory.StatusCoreComponentsHolder,
 	coreComponents mainFactory.CoreComponentsHolder,
 	cryptoComponents mainFactory.CryptoComponentsHolder,
-	bootstrapComponents mainFactory.BootstrapComponentsHolder,
 ) error {
-
-	chainParameters, err := coreComponents.ChainParametersHandler().ChainParametersForEpoch(bootstrapComponents.EpochBootstrapParams().Epoch())
-	if err != nil {
-		return err
-	}
-
-	err = metrics.InitMetrics(
+	err := metrics.InitInitialMetrics(
 		statusCoreComponents.AppStatusHandler(),
 		cryptoComponents.PublicKeyString(),
-		bootstrapComponents.NodeType(),
-		bootstrapComponents.ShardCoordinator(),
 		coreComponents.GenesisNodesSetup(),
 		nr.configs.FlagsConfig.Version,
 		nr.configs.EconomicsConfig,
-		chainParameters,
 		coreComponents.MinTransactionVersion(),
 	)
-
 	if err != nil {
 		return err
 	}
 
+	nr.setMetricsAtInit(statusCoreComponents, coreComponents)
+
+	return nil
+}
+
+func (nr *nodeRunner) setMetricsAtInit(
+	statusCoreComponents mainFactory.StatusCoreComponentsHolder,
+	coreComponents mainFactory.CoreComponentsHolder,
+) {
 	metrics.SaveStringMetric(statusCoreComponents.AppStatusHandler(), common.MetricNodeDisplayName, nr.configs.PreferencesConfig.Preferences.NodeDisplayName)
 	metrics.SaveStringMetric(statusCoreComponents.AppStatusHandler(), common.MetricRedundancyLevel, fmt.Sprintf("%d", nr.configs.PreferencesConfig.Preferences.RedundancyLevel))
 	metrics.SaveStringMetric(statusCoreComponents.AppStatusHandler(), common.MetricRedundancyIsMainActive, common.MetricValueNA)
@@ -874,6 +878,37 @@ func (nr *nodeRunner) createMetrics(
 		metrics.SaveStringMetric(statusCoreComponents.AppStatusHandler(), common.MetricPeerType, core.ObserverPeer.String())
 		metrics.SaveStringMetric(statusCoreComponents.AppStatusHandler(), common.MetricPeerSubType, core.FullHistoryObserver.String())
 	}
+}
+
+func (nr *nodeRunner) createMetrics(
+	statusCoreComponents mainFactory.StatusCoreComponentsHolder,
+	coreComponents mainFactory.CoreComponentsHolder,
+	cryptoComponents mainFactory.CryptoComponentsHolder,
+	bootstrapComponents mainFactory.BootstrapComponentsHolder,
+) error {
+
+	chainParameters, err := coreComponents.ChainParametersHandler().ChainParametersForEpoch(bootstrapComponents.EpochBootstrapParams().Epoch())
+	if err != nil {
+		return err
+	}
+
+	err = metrics.InitMetrics(
+		statusCoreComponents.AppStatusHandler(),
+		cryptoComponents.PublicKeyString(),
+		bootstrapComponents.NodeType(),
+		bootstrapComponents.ShardCoordinator(),
+		coreComponents.GenesisNodesSetup(),
+		nr.configs.FlagsConfig.Version,
+		nr.configs.EconomicsConfig,
+		chainParameters,
+		coreComponents.MinTransactionVersion(),
+	)
+
+	if err != nil {
+		return err
+	}
+
+	nr.setMetricsAtInit(statusCoreComponents, coreComponents)
 
 	return nil
 }