fix: evm-single sequencer metrics (#2382)

## Overview

Sequencer specific metrics (GasPrice, LastBlobSize, TransactionStatus,
TransactionStatus, IncludedBlockHeight) were not displayed on the
prometheus metrics endpoint.
Only rollkit_sequencer_* (block_size, height,
latest_block_height,num_txs,total_txs) were displayed.

This PR update the evm-single run command to include missing metrics.

```bash
curl -s localhost:26660/metrics | grep -i pending
# HELP sequencer_num_pending_blocks The number of pending blocks for DA submission.
# TYPE sequencer_num_pending_blocks gauge
sequencer_num_pending_blocks{chain_id="rollkit-test"} 7
```

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Enhanced metrics reporting for sequencer operations, including updates
after data availability submissions and block height changes.
- Introduced a public method for recording sequencer metrics, providing
more detailed tracking of gas price, blob size, transaction status,
pending blocks, and block heights.
- Added a standardized interface to unify metrics recording across
components.
- **Tests**
- Added comprehensive tests to verify metrics recording during data
availability submissions and block height increments.
- Introduced mocks and test coverage to ensure metrics integration
behaves correctly under various scenarios.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: auricom

apps/evm/single/cmd/run.go

@@ -60,10 +60,10 @@ var RunCmd = &cobra.Command{
 			return err
 		}
 
-		singleMetrics, err := single.NopMetrics()
-		if err != nil {
-			return err
-		}
+	singleMetrics, err := single.DefaultMetricsProvider(nodeConfig.Instrumentation.IsPrometheusEnabled())(nodeConfig.ChainID)
+	if err != nil {
+		return err
+	}
 
 		sequencer, err := single.NewSequencer(
 			context.Background(),

block/da_includer.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"encoding/binary"
 	"fmt"
+
+	coreda "github.com/rollkit/rollkit/core/da"
 )
 
 // DAIncluderLoop is responsible for advancing the DAIncludedHeight by checking if blocks after the current height
@@ -63,5 +65,11 @@ func (m *Manager) incrementDAIncludedHeight(ctx context.Context) error {
 	if !m.daIncludedHeight.CompareAndSwap(currentHeight, newHeight) {
 		return fmt.Errorf("failed to set DA included height: %d", newHeight)
 	}
+
+	// Update sequencer metrics if the sequencer supports it
+	if seq, ok := m.sequencer.(MetricsRecorder); ok {
+		seq.RecordMetrics(m.gasPrice, 0, coreda.StatusSuccess, m.pendingHeaders.numPendingHeaders(), newHeight)
+	}
+
 	return nil
 }

block/da_includer_test.go

@@ -10,6 +10,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 
+	coreda "github.com/rollkit/rollkit/core/da"
+	"github.com/rollkit/rollkit/core/sequencer"
 	"github.com/rollkit/rollkit/pkg/cache"
 	"github.com/rollkit/rollkit/test/mocks"
 	"github.com/rollkit/rollkit/types"
@@ -369,6 +371,83 @@ func TestDAIncluderLoop_DoesNotAdvanceWhenDataHashIsEmptyAndHeaderNotDAIncluded(
 	store.AssertExpectations(t)
 }
 
+// MockSequencerWithMetrics is a mock sequencer that implements MetricsRecorder interface
+type MockSequencerWithMetrics struct {
+	mock.Mock
+}
+
+func (m *MockSequencerWithMetrics) RecordMetrics(gasPrice float64, blobSize uint64, statusCode coreda.StatusCode, numPendingBlocks uint64, includedBlockHeight uint64) {
+	m.Called(gasPrice, blobSize, statusCode, numPendingBlocks, includedBlockHeight)
+}
+
+// Implement the Sequencer interface methods
+func (m *MockSequencerWithMetrics) SubmitBatchTxs(ctx context.Context, req sequencer.SubmitBatchTxsRequest) (*sequencer.SubmitBatchTxsResponse, error) {
+	args := m.Called(ctx, req)
+	return args.Get(0).(*sequencer.SubmitBatchTxsResponse), args.Error(1)
+}
+
+func (m *MockSequencerWithMetrics) GetNextBatch(ctx context.Context, req sequencer.GetNextBatchRequest) (*sequencer.GetNextBatchResponse, error) {
+	args := m.Called(ctx, req)
+	return args.Get(0).(*sequencer.GetNextBatchResponse), args.Error(1)
+}
+
+func (m *MockSequencerWithMetrics) VerifyBatch(ctx context.Context, req sequencer.VerifyBatchRequest) (*sequencer.VerifyBatchResponse, error) {
+	args := m.Called(ctx, req)
+	return args.Get(0).(*sequencer.VerifyBatchResponse), args.Error(1)
+}
+
+// TestIncrementDAIncludedHeight_WithMetricsRecorder verifies that incrementDAIncludedHeight calls RecordMetrics
+// when the sequencer implements the MetricsRecorder interface (covers lines 73-74).
+func TestIncrementDAIncludedHeight_WithMetricsRecorder(t *testing.T) {
+	t.Parallel()
+	m, store, exec, logger := newTestManager(t)
+	startDAIncludedHeight := uint64(4)
+	expectedDAIncludedHeight := startDAIncludedHeight + 1
+	m.daIncludedHeight.Store(startDAIncludedHeight)
+
+	// Set up mock sequencer with metrics
+	mockSequencer := new(MockSequencerWithMetrics)
+	m.sequencer = mockSequencer
+	m.gasPrice = 1.5 // Set a test gas price
+
+	// Mock the store calls needed for PendingHeaders initialization
+	// First, clear the existing Height mock from newTestManager
+	store.ExpectedCalls = nil
+
+	// Create a byte array representing lastSubmittedHeight = 4
+	lastSubmittedBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(lastSubmittedBytes, startDAIncludedHeight)
+
+	store.On("GetMetadata", mock.Anything, LastSubmittedHeightKey).Return(lastSubmittedBytes, nil).Maybe() // For pendingHeaders init
+	store.On("Height", mock.Anything).Return(uint64(7), nil).Maybe()                                       // 7 - 4 = 3 pending headers
+
+	// Initialize pendingHeaders properly
+	pendingHeaders, err := NewPendingHeaders(store, logger)
+	assert.NoError(t, err)
+	m.pendingHeaders = pendingHeaders
+
+	heightBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(heightBytes, expectedDAIncludedHeight)
+	store.On("SetMetadata", mock.Anything, DAIncludedHeightKey, heightBytes).Return(nil).Once()
+	exec.On("SetFinal", mock.Anything, expectedDAIncludedHeight).Return(nil).Once()
+
+	// Expect RecordMetrics to be called with the correct parameters
+	mockSequencer.On("RecordMetrics",
+		float64(1.5),             // gasPrice
+		uint64(0),                // blobSize
+		coreda.StatusSuccess,     // statusCode
+		uint64(3),                // numPendingBlocks (7 - 4 = 3)
+		expectedDAIncludedHeight, // includedBlockHeight
+	).Once()
+
+	err = m.incrementDAIncludedHeight(context.Background())
+	assert.NoError(t, err)
+	assert.Equal(t, expectedDAIncludedHeight, m.GetDAIncludedHeight())
+	store.AssertExpectations(t)
+	exec.AssertExpectations(t)
+	mockSequencer.AssertExpectations(t)
+}
+
 // Note: It is not practical to unit test a CompareAndSwap failure for incrementDAIncludedHeight
 // because the atomic value is always read at the start of the function, and there is no way to
 // inject a failure or race another goroutine reliably in a unit test. To test this path, the code

block/manager.go

@@ -69,6 +69,13 @@ var (
 // This allows for overriding the behavior in tests.
 type publishBlockFunc func(ctx context.Context) error
 
+// MetricsRecorder defines the interface for sequencers that support recording metrics.
+// This interface is used to avoid duplication of the anonymous interface definition
+// across multiple files in the block package.
+type MetricsRecorder interface {
+	RecordMetrics(gasPrice float64, blobSize uint64, statusCode coreda.StatusCode, numPendingBlocks uint64, includedBlockHeight uint64)
+}
+
 func defaultSignaturePayloadProvider(header *types.Header) ([]byte, error) {
 	return header.MarshalBinary()
 }

block/submitter.go

@@ -106,6 +106,11 @@ func (m *Manager) submitHeadersToDA(ctx context.Context) error {
 				gasPrice = max(gasPrice, initialGasPrice)
 			}
 			m.logger.Debug("resetting DA layer submission options", "backoff", backoff, "gasPrice", gasPrice)
+
+			// Update sequencer metrics if the sequencer supports it
+			if seq, ok := m.sequencer.(MetricsRecorder); ok {
+				seq.RecordMetrics(gasPrice, res.BlobSize, res.Code, m.pendingHeaders.numPendingHeaders(), lastSubmittedHeight)
+			}
 		case coreda.StatusNotIncludedInBlock, coreda.StatusAlreadyInMempool:
 			m.logger.Error("DA layer submission failed", "error", res.Message, "attempt", attempt)
 			backoff = m.config.DA.BlockTime.Duration * time.Duration(m.config.DA.MempoolTTL) //nolint:gosec
@@ -256,6 +261,13 @@ func (m *Manager) submitDataToDA(ctx context.Context, signedData *types.SignedDa
 
 			m.DataCache().SetDAIncluded(signedData.DACommitment().String())
 			m.sendNonBlockingSignalToDAIncluderCh()
+
+			// Update sequencer metrics if the sequencer supports it
+			if seq, ok := m.sequencer.(MetricsRecorder); ok {
+				daIncludedHeight := m.GetDAIncludedHeight()
+				seq.RecordMetrics(gasPrice, res.BlobSize, res.Code, m.pendingHeaders.numPendingHeaders(), daIncludedHeight)
+			}
+
 			return nil
 
 		case coreda.StatusNotIncludedInBlock, coreda.StatusAlreadyInMempool:

block/submitter_test.go

@@ -209,6 +209,103 @@ func TestSubmitHeadersToDA_Failure(t *testing.T) {
 	}
 }
 
+// TestSubmitHeadersToDA_WithMetricsRecorder verifies that submitHeadersToDA calls RecordMetrics
+// when the sequencer implements the MetricsRecorder interface.
+func TestSubmitHeadersToDA_WithMetricsRecorder(t *testing.T) {
+	da := &mocks.DA{}
+	m := newTestManagerWithDA(t, da)
+
+	// Set up mock sequencer with metrics
+	mockSequencer := new(MockSequencerWithMetrics)
+	m.sequencer = mockSequencer
+
+	// Prepare a mock PendingHeaders with test data
+	m.pendingHeaders = newPendingBlocks(t)
+
+	// Fill the pending headers with mock block data
+	fillWithBlockData(context.Background(), t, m.pendingHeaders, "Test Submitting Headers")
+
+	// Simulate DA layer successfully accepting the header submission
+	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+		Return([]coreda.ID{[]byte("id")}, nil)
+
+	// Expect RecordMetrics to be called with the correct parameters
+	// Allow multiple calls since fillWithBlockData might create multiple headers
+	mockSequencer.On("RecordMetrics",
+		float64(1.0),                  // gasPrice (from newTestManagerWithDA)
+		uint64(0),                     // blobSize (mocked as 0)
+		coreda.StatusSuccess,          // statusCode
+		mock.AnythingOfType("uint64"), // numPendingBlocks (varies based on test data)
+		mock.AnythingOfType("uint64"), // lastSubmittedHeight
+	).Maybe()
+
+	// Call submitHeadersToDA and expect no error
+	err := m.submitHeadersToDA(context.Background())
+	assert.NoError(t, err)
+
+	// Verify that RecordMetrics was called at least once
+	mockSequencer.AssertExpectations(t)
+}
+
+// TestSubmitDataToDA_WithMetricsRecorder verifies that submitDataToDA calls RecordMetrics
+// when the sequencer implements the MetricsRecorder interface.
+func TestSubmitDataToDA_WithMetricsRecorder(t *testing.T) {
+	da := &mocks.DA{}
+	m := newTestManagerWithDA(t, da)
+
+	// Set up mock sequencer with metrics
+	mockSequencer := new(MockSequencerWithMetrics)
+	m.sequencer = mockSequencer
+
+	// Initialize pendingHeaders to avoid nil pointer dereference
+	m.pendingHeaders = newPendingBlocks(t)
+
+	// Simulate DA success
+	da.On("GasMultiplier", mock.Anything).Return(2.0, nil)
+	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+		Return([]coreda.ID{[]byte("id")}, nil)
+
+	// Expect RecordMetrics to be called with the correct parameters
+	mockSequencer.On("RecordMetrics",
+		float64(1.0),                  // gasPrice (from newTestManagerWithDA)
+		uint64(0),                     // blobSize (mocked as 0)
+		coreda.StatusSuccess,          // statusCode
+		mock.AnythingOfType("uint64"), // numPendingBlocks (varies based on test data)
+		mock.AnythingOfType("uint64"), // daIncludedHeight
+	).Once()
+
+	pubKey, err := m.signer.GetPublic()
+	require.NoError(t, err)
+	addr, err := m.signer.GetAddress()
+	require.NoError(t, err)
+
+	transactions := [][]byte{[]byte("tx1"), []byte("tx2")}
+
+	signedData := types.SignedData{
+		Data: types.Data{
+			Txs: make(types.Txs, len(transactions)),
+		},
+		Signer: types.Signer{
+			Address: addr,
+			PubKey:  pubKey,
+		},
+	}
+
+	for i, tx := range transactions {
+		signedData.Txs[i] = types.Tx(tx)
+	}
+
+	signature, err := m.getDataSignature(&signedData.Data)
+	require.NoError(t, err)
+	signedData.Signature = signature
+
+	err = m.submitDataToDA(context.Background(), &signedData)
+	assert.NoError(t, err)
+
+	// Verify that RecordMetrics was called
+	mockSequencer.AssertExpectations(t)
+}
+
 // TestCreateSignedDataFromBatch tests createSignedDataFromBatch for normal, empty, and error cases.
 func TestCreateSignedDataFromBatch(t *testing.T) {
 	// Setup: create a Manager with a valid signer and genesis proposer address

sequencers/single/sequencer.go

@@ -122,7 +122,9 @@ func (c *Sequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextB
 	}, nil
 }
 
-func (c *Sequencer) recordMetrics(gasPrice float64, blobSize uint64, statusCode coreda.StatusCode, numPendingBlocks int, includedBlockHeight uint64) {
+// RecordMetrics updates the metrics with the given values.
+// This method is intended to be called by the block manager after submitting data to the DA layer.
+func (c *Sequencer) RecordMetrics(gasPrice float64, blobSize uint64, statusCode coreda.StatusCode, numPendingBlocks uint64, includedBlockHeight uint64) {
 	if c.metrics != nil {
 		c.metrics.GasPrice.Set(gasPrice)
 		c.metrics.LastBlobSize.Set(float64(blobSize))

sequencers/single/sequencer_test.go

@@ -431,3 +431,86 @@ func TestSequencer_GetNextBatch_BeforeDASubmission(t *testing.T) {
 	// Verify all mock expectations were met
 	mockDA.AssertExpectations(t)
 }
+
+// TestSequencer_RecordMetrics tests the RecordMetrics method to ensure it properly updates metrics.
+func TestSequencer_RecordMetrics(t *testing.T) {
+	t.Run("With Metrics", func(t *testing.T) {
+		// Create a sequencer with metrics enabled
+		metrics, err := NopMetrics()
+		require.NoError(t, err)
+
+		seq := &Sequencer{
+			logger:  log.NewNopLogger(),
+			metrics: metrics,
+		}
+
+		// Test values
+		gasPrice := 1.5
+		blobSize := uint64(1024)
+		statusCode := coreda.StatusSuccess
+		numPendingBlocks := uint64(5)
+		includedBlockHeight := uint64(100)
+
+		// Call RecordMetrics - should not panic or error
+		seq.RecordMetrics(gasPrice, blobSize, statusCode, numPendingBlocks, includedBlockHeight)
+
+		// Since we're using NopMetrics (discard metrics), we can't verify the actual values
+		// but we can verify the method doesn't panic and completes successfully
+		assert.NotNil(t, seq.metrics)
+	})
+
+	t.Run("Without Metrics", func(t *testing.T) {
+		// Create a sequencer without metrics
+		seq := &Sequencer{
+			logger:  log.NewNopLogger(),
+			metrics: nil, // No metrics
+		}
+
+		// Test values
+		gasPrice := 2.0
+		blobSize := uint64(2048)
+		statusCode := coreda.StatusNotIncludedInBlock
+		numPendingBlocks := uint64(3)
+		includedBlockHeight := uint64(200)
+
+		// Call RecordMetrics - should not panic even with nil metrics
+		seq.RecordMetrics(gasPrice, blobSize, statusCode, numPendingBlocks, includedBlockHeight)
+
+		// Verify metrics is still nil
+		assert.Nil(t, seq.metrics)
+	})
+
+	t.Run("With Different Status Codes", func(t *testing.T) {
+		// Create a sequencer with metrics
+		metrics, err := NopMetrics()
+		require.NoError(t, err)
+
+		seq := &Sequencer{
+			logger:  log.NewNopLogger(),
+			metrics: metrics,
+		}
+
+		// Test different status codes
+		testCases := []struct {
+			name       string
+			statusCode coreda.StatusCode
+		}{
+			{"Success", coreda.StatusSuccess},
+			{"NotIncluded", coreda.StatusNotIncludedInBlock},
+			{"AlreadyInMempool", coreda.StatusAlreadyInMempool},
+			{"TooBig", coreda.StatusTooBig},
+			{"ContextCanceled", coreda.StatusContextCanceled},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				// Call RecordMetrics with different status codes
+				seq.RecordMetrics(1.0, 512, tc.statusCode, 2, 50)
+
+				// Verify no panic occurred
+				assert.NotNil(t, seq.metrics)
+			})
+		}
+	})
+
+}