[KLC-2388] Gate klv_node_type / klv_peer_type writes on cache miss

cmd/node/metrics/metrics.go

@@ -44,7 +44,17 @@ func InitMetrics(
 	initZeroString := "0"
 
 	appStatusHandler.SetStringValue(core.MetricPublicKeyBlockSign, pubkeyStr)
+	// KLC-2388: node_type stays "validator" during the bootstrap window even
+	// though peer_type below is seeded to "observer". The two intentionally
+	// diverge until the peerTypeProvider cache populates: node_type is the
+	// PR's protected value (the original bug was validators flipping to
+	// observer on cache miss), so we cannot seed it observer without
+	// re-introducing exactly that symptom; peer_type is left pessimistic
+	// because it's a peer-list classification that we genuinely don't know
+	// yet. Once the gate opens the sender writes the real values from the
+	// fork detector / nodes coordinator.
 	appStatusHandler.SetStringValue(core.MetricNodeType, string(nodeType))
+	appStatusHandler.SetStringValue(core.MetricPeerType, string(core.ObserverList))
 	appStatusHandler.SetUInt64Value(core.MetricSlotTime, slotInterval/millisecondsInSecond)
 	appStatusHandler.SetStringValue(core.MetricAppVersion, version)
 	appStatusHandler.SetUInt64Value(core.MetricSlotsPerEpoch, uint64(slotsPerEpoch))

core/process/peer/peerTypeProvider.go

@@ -23,6 +23,7 @@ type PeerTypeProvider struct {
 	nodesCoordinator sharding.NodesCoordinator
 	cache            map[string]*peerListAndShard
 	mutCache         sync.RWMutex
+	isReady          bool
 }
 
 // ArgPeerTypeProvider contains all parameters needed for creating a PeerTypeProvider
@@ -54,6 +55,16 @@ func NewPeerTypeProvider(arg ArgPeerTypeProvider) (*PeerTypeProvider, error) {
 	return ptp, nil
 }
 
+// IsCachePopulated returns true once at least one updateCache call has produced a
+// non-empty cache. Until then, the NodesCoordinator has not yet exposed any
+// validator keys for the active epoch, so callers should treat the peer-type result
+// as unreliable and avoid overwriting startup-seeded values.
+func (ptp *PeerTypeProvider) IsCachePopulated() bool {
+	ptp.mutCache.RLock()
+	defer ptp.mutCache.RUnlock()
+	return ptp.isReady
+}
+
 // ComputeForPubKey returns the peer type for a given public key and shard id
 func (ptp *PeerTypeProvider) ComputeForPubKey(pubKey []byte) (core.PeerType, uint32, error) {
 	ptp.mutCache.RLock()
@@ -105,6 +116,9 @@ func (ptp *PeerTypeProvider) updateCache(epoch uint32) {
 
 	ptp.mutCache.Lock()
 	ptp.cache = newCache
+	if len(newCache) > 0 {
+		ptp.isReady = true
+	}
 	ptp.mutCache.Unlock()
 }
 

core/process/peer/peerTypeProvider_test.go

@@ -205,6 +205,67 @@ func TestNewPeerTypeProvider_ComputeForKeyNotFoundInCacheReturnsObserver(t *test
 	assert.Nil(t, err)
 }
 
+func TestPeerTypeProvider_IsCachePopulated_FalseWhenCoordinatorReturnsEmpty(t *testing.T) {
+	arg := createDefaultArgPeerTypeProvider()
+
+	ptp, err := NewPeerTypeProvider(arg)
+	require.Nil(t, err)
+	require.NotNil(t, ptp)
+
+	assert.False(t, ptp.IsCachePopulated())
+}
+
+func TestPeerTypeProvider_IsCachePopulated_TrueAtConstructionWhenCachePopulated(t *testing.T) {
+	arg := createDefaultArgPeerTypeProvider()
+	arg.NodesCoordinator = &mock.NodesCoordinatorMock{
+		GetAllElectedValidatorsKeysCalled: func() ([][]byte, error) {
+			return [][]byte{[]byte("validator-pk")}, nil
+		},
+	}
+
+	ptp, err := NewPeerTypeProvider(arg)
+	require.Nil(t, err)
+	require.NotNil(t, ptp)
+
+	assert.True(t, ptp.IsCachePopulated())
+}
+
+func TestPeerTypeProvider_IsCachePopulated_TrueAfterEpochStartFillsCache(t *testing.T) {
+	arg := createDefaultArgPeerTypeProvider()
+	epochStartNotifier := &mock.EpochStartNotifierStub{}
+	arg.EpochStartEventNotifier = epochStartNotifier
+
+	coordinator := &mock.NodesCoordinatorMock{}
+	arg.NodesCoordinator = coordinator
+
+	ptp, err := NewPeerTypeProvider(arg)
+	require.Nil(t, err)
+	require.NotNil(t, ptp)
+	require.False(t, ptp.IsCachePopulated())
+
+	coordinator.GetAllElectedValidatorsKeysCalled = func() ([][]byte, error) {
+		return [][]byte{[]byte("validator-pk")}, nil
+	}
+	epochStartNotifier.NotifyAll(&block.Block{Header: &block.BlockHeader{Nonce: 1, Epoch: 1}})
+
+	assert.True(t, ptp.IsCachePopulated())
+}
+
+func TestPeerTypeProvider_IsCachePopulated_StaysFalseWhenEpochStartFiresButCacheEmpty(t *testing.T) {
+	arg := createDefaultArgPeerTypeProvider()
+	epochStartNotifier := &mock.EpochStartNotifierStub{}
+	arg.EpochStartEventNotifier = epochStartNotifier
+
+	ptp, err := NewPeerTypeProvider(arg)
+	require.Nil(t, err)
+	require.NotNil(t, ptp)
+	require.False(t, ptp.IsCachePopulated())
+
+	epochStartNotifier.NotifyAll(&block.Block{Header: &block.BlockHeader{Nonce: 1, Epoch: 1}})
+
+	assert.False(t, ptp.IsCachePopulated())
+}
+
 func TestNewPeerTypeProvider_IsInterfaceNil(t *testing.T) {
 	arg := createDefaultArgPeerTypeProvider()
 

node/heartbeat/interface.go

@@ -80,6 +80,7 @@ type P2PAntifloodHandler interface {
 type PeerTypeProviderHandler interface {
 	ComputeForPubKey(pubKey []byte) (core.PeerType, uint32, error)
 	GetAllPeerTypeInfos() []*state.PeerTypeInfo
+	IsCachePopulated() bool
 	IsInterfaceNil() bool
 }
 

node/heartbeat/mock/peerTypeProviderStub.go

@@ -8,6 +8,7 @@ import (
 // PeerTypeProviderStub -
 type PeerTypeProviderStub struct {
 	ComputeForPubKeyCalled func(pubKey []byte) (core.PeerType, uint32, error)
+	IsCachePopulatedCalled func() bool
 }
 
 // ComputeForPubKey -
@@ -24,6 +25,15 @@ func (p *PeerTypeProviderStub) GetAllPeerTypeInfos() []*state.PeerTypeInfo {
 	return nil
 }
 
+// IsCachePopulated -
+func (p *PeerTypeProviderStub) IsCachePopulated() bool {
+	if p.IsCachePopulatedCalled != nil {
+		return p.IsCachePopulatedCalled()
+	}
+
+	return true
+}
+
 // IsInterfaceNil -
 func (p *PeerTypeProviderStub) IsInterfaceNil() bool {
 	return p == nil

node/heartbeat/process/export_test.go

@@ -92,6 +92,11 @@ func VerifyLengths(hbmi *data.Heartbeat) error {
 	return verifyLengths(hbmi)
 }
 
+// UpdateMetrics -
+func (s *Sender) UpdateMetrics(hb *data.Heartbeat) {
+	s.updateMetrics(hb)
+}
+
 // GetMaxSizeInBytes -
 func GetMaxSizeInBytes() int {
 	return maxSizeInBytes

node/heartbeat/process/sender.go

@@ -174,6 +174,10 @@ func (s *Sender) getCurrentPrivateAndPublicKeys() (crypto.PrivateKey, crypto.Pub
 }
 
 func (s *Sender) updateMetrics(hb *heartbeatData.Heartbeat) {
+	if !s.peerTypeProvider.IsCachePopulated() {
+		return
+	}
+
 	result := s.computePeerList(hb.Pubkey)
 
 	nodeType := ""

node/heartbeat/process/sender_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	cMock "github.com/klever-io/klever-go/common/mock"
+	"github.com/klever-io/klever-go/core"
 	"github.com/klever-io/klever-go/crypto"
 	"github.com/klever-io/klever-go/node/heartbeat"
 	"github.com/klever-io/klever-go/node/heartbeat/data"
@@ -621,3 +622,62 @@ func TestSender_SendHeartbeatAfterTriggerWithRecorededPayloadShouldWork(t *testi
 	assert.True(t, genPubKeyCalled)
 	assert.True(t, marshalCalled)
 }
+
+func TestSender_UpdateMetricsSkipsWritesWhenCacheNotPopulated(t *testing.T) {
+	t.Parallel()
+
+	arg := createMockArgHeartbeatSender()
+	arg.PeerTypeProvider = &mock.PeerTypeProviderStub{
+		IsCachePopulatedCalled: func() bool {
+			return false
+		},
+		ComputeForPubKeyCalled: func(pubKey []byte) (core.PeerType, uint32, error) {
+			t.Fatalf("ComputeForPubKey must not be called when cache is not populated")
+			return "", 0, nil
+		},
+	}
+	setStringCalls := make(map[string]string)
+	arg.StatusHandler = &mock.AppStatusHandlerStub{
+		SetStringValueHandler: func(key string, value string) {
+			setStringCalls[key] = value
+		},
+	}
+
+	sender, err := process.NewSender(arg)
+	assert.Nil(t, err)
+
+	sender.UpdateMetrics(&data.Heartbeat{Pubkey: []byte("pk")})
+
+	_, gotNodeType := setStringCalls[core.MetricNodeType]
+	_, gotPeerType := setStringCalls[core.MetricPeerType]
+	assert.False(t, gotNodeType)
+	assert.False(t, gotPeerType)
+}
+
+func TestSender_UpdateMetricsWritesWhenCachePopulated(t *testing.T) {
+	t.Parallel()
+
+	arg := createMockArgHeartbeatSender()
+	arg.PeerTypeProvider = &mock.PeerTypeProviderStub{
+		IsCachePopulatedCalled: func() bool {
+			return true
+		},
+		ComputeForPubKeyCalled: func(pubKey []byte) (core.PeerType, uint32, error) {
+			return core.EligibleList, 0, nil
+		},
+	}
+	setStringCalls := make(map[string]string)
+	arg.StatusHandler = &mock.AppStatusHandlerStub{
+		SetStringValueHandler: func(key string, value string) {
+			setStringCalls[key] = value
+		},
+	}
+
+	sender, err := process.NewSender(arg)
+	assert.Nil(t, err)
+
+	sender.UpdateMetrics(&data.Heartbeat{Pubkey: []byte("pk")})
+
+	assert.Equal(t, string(core.NodeTypeValidator), setStringCalls[core.MetricNodeType])
+	assert.Equal(t, string(core.EligibleList), setStringCalls[core.MetricPeerType])
+}