update

Author: Larry Li

multinode/rpc_client_base.go

@@ -17,7 +17,6 @@ var errInvalidHead = errors.New("invalid head")
 const (
 	rpcCallNameLatestBlock          = "latest_block"
 	rpcCallNameLatestFinalizedBlock = "latest_finalized_block"
-	rpcMetricsDefaultURL            = ""
 	rpcMetricsDefaultIsSendOnly     = false
 )
 
@@ -37,6 +36,7 @@ type RPCClientBase[HEAD Head] struct {
 	cfg        RPCClientBaseConfig
 	log        logger.Logger
 	ctxTimeout time.Duration
+	rpcURL     string
 	subsMu     sync.RWMutex
 	subs       map[Subscription]struct{}
 
@@ -64,12 +64,14 @@ func NewRPCClientBase[HEAD Head](
 	cfg RPCClientBaseConfig, ctxTimeout time.Duration, log logger.Logger,
 	latestBlock func(ctx context.Context) (HEAD, error),
 	latestFinalizedBlock func(ctx context.Context) (HEAD, error),
+	rpcURL string,
 	rpcMetrics frameworkmetrics.RPCClientMetrics,
 ) *RPCClientBase[HEAD] {
 	base := &RPCClientBase[HEAD]{
 		cfg:                  cfg,
 		log:                  log,
 		ctxTimeout:           ctxTimeout,
+		rpcURL:               rpcURL,
 		latestBlock:          latestBlock,
 		latestFinalizedBlock: latestFinalizedBlock,
 		subs:                 make(map[Subscription]struct{}),
@@ -214,7 +216,7 @@ func (m *RPCClientBase[HEAD]) recordRPCRequest(ctx context.Context, callName str
 		return
 	}
 
-	m.rpcMetrics.RecordRequest(ctx, rpcMetricsDefaultURL, rpcMetricsDefaultIsSendOnly, callName, time.Since(startedAt), err)
+	m.rpcMetrics.RecordRequest(ctx, m.rpcURL, rpcMetricsDefaultIsSendOnly, callName, time.Since(startedAt), err)
 }
 
 func (m *RPCClientBase[HEAD]) OnNewHead(ctx context.Context, requestCh <-chan struct{}, head HEAD) {

multinode/rpc_client_base_test.go

@@ -68,15 +68,17 @@ func newTestRPC(t *testing.T) *testRPC {
 	}
 
 	rpc := &testRPC{}
-	rpc.RPCClientBase = NewRPCClientBase[*testHead](cfg, requestTimeout, lggr, rpc.latestBlock, rpc.latestBlock, nil)
+	rpc.RPCClientBase = NewRPCClientBase[*testHead](cfg, requestTimeout, lggr, rpc.latestBlock, rpc.latestBlock, "http://localhost:8545", nil)
 	t.Cleanup(rpc.Close)
 	return rpc
 }
 
 type recordedRPCRequest struct {
-	callName string
-	latency  time.Duration
-	err      error
+	rpcURL     string
+	isSendOnly bool
+	callName   string
+	latency    time.Duration
+	err        error
 }
 
 type spyRPCClientMetrics struct {
@@ -85,11 +87,13 @@ type spyRPCClientMetrics struct {
 
 var _ frameworkmetrics.RPCClientMetrics = (*spyRPCClientMetrics)(nil)
 
-func (s *spyRPCClientMetrics) RecordRequest(_ context.Context, _ string, _ bool, callName string, latency time.Duration, err error) {
+func (s *spyRPCClientMetrics) RecordRequest(_ context.Context, rpcURL string, isSendOnly bool, callName string, latency time.Duration, err error) {
 	s.requests = append(s.requests, recordedRPCRequest{
-		callName: callName,
-		latency:  latency,
-		err:      err,
+		rpcURL:     rpcURL,
+		isSendOnly: isSendOnly,
+		callName:   callName,
+		latency:    latency,
+		err:        err,
 	})
 }
 
@@ -147,6 +151,7 @@ func TestRPCClientBase_RecordsRPCMetrics(t *testing.T) {
 
 	t.Run("records successful latest block requests", func(t *testing.T) {
 		spy := &spyRPCClientMetrics{}
+		const testURL = "http://rpc.example.com:8545"
 		rpc := NewRPCClientBase[*testHead](
 			cfg,
 			requestTimeout,
@@ -157,20 +162,24 @@ func TestRPCClientBase_RecordsRPCMetrics(t *testing.T) {
 			func(context.Context) (*testHead, error) {
 				return &testHead{blockNumber: 8}, nil
 			},
+			testURL,
 			spy,
 		)
 
 		head, err := rpc.LatestBlock(t.Context())
 		require.NoError(t, err)
 		require.Equal(t, int64(7), head.BlockNumber())
 		require.Len(t, spy.requests, 1)
+		require.Equal(t, testURL, spy.requests[0].rpcURL)
+		require.False(t, spy.requests[0].isSendOnly)
 		require.Equal(t, rpcCallNameLatestBlock, spy.requests[0].callName)
 		require.NoError(t, spy.requests[0].err)
 		require.Positive(t, spy.requests[0].latency)
 	})
 
 	t.Run("records failed finalized block requests", func(t *testing.T) {
 		spy := &spyRPCClientMetrics{}
+		const testURL = "http://rpc.example.com:8545"
 		expectedErr := errors.New("boom")
 		rpc := NewRPCClientBase[*testHead](
 			cfg,
@@ -182,19 +191,23 @@ func TestRPCClientBase_RecordsRPCMetrics(t *testing.T) {
 			func(context.Context) (*testHead, error) {
 				return nil, expectedErr
 			},
+			testURL,
 			spy,
 		)
 
 		_, err := rpc.LatestFinalizedBlock(t.Context())
 		require.ErrorIs(t, err, expectedErr)
 		require.Len(t, spy.requests, 1)
+		require.Equal(t, testURL, spy.requests[0].rpcURL)
+		require.False(t, spy.requests[0].isSendOnly)
 		require.Equal(t, rpcCallNameLatestFinalizedBlock, spy.requests[0].callName)
 		require.ErrorIs(t, spy.requests[0].err, expectedErr)
 		require.Positive(t, spy.requests[0].latency)
 	})
 
 	t.Run("records invalid heads as failed requests", func(t *testing.T) {
 		spy := &spyRPCClientMetrics{}
+		const testURL = "http://rpc.example.com:8545"
 		rpc := NewRPCClientBase[*testHead](
 			cfg,
 			requestTimeout,
@@ -205,12 +218,15 @@ func TestRPCClientBase_RecordsRPCMetrics(t *testing.T) {
 			func(context.Context) (*testHead, error) {
 				return &testHead{blockNumber: 8}, nil
 			},
+			testURL,
 			spy,
 		)
 
 		_, err := rpc.LatestBlock(t.Context())
 		require.ErrorIs(t, err, errInvalidHead)
 		require.Len(t, spy.requests, 1)
+		require.Equal(t, testURL, spy.requests[0].rpcURL)
+		require.False(t, spy.requests[0].isSendOnly)
 		require.Equal(t, rpcCallNameLatestBlock, spy.requests[0].callName)
 		require.ErrorIs(t, spy.requests[0].err, errInvalidHead)
 	})