allow use of nil metrics

op-node/metrics/metrics.go

@@ -32,6 +32,32 @@ const (
 	BatchMethod = "<batch>"
 )
 
+type Metricer interface {
+	RecordInfo(version string)
+	RecordUp()
+	RecordRPCServerRequest(method string) func()
+	RecordRPCClientRequest(method string) func(err error)
+	RecordRPCClientResponse(method string, err error)
+	SetDerivationIdle(status bool)
+	RecordPipelineReset()
+	RecordSequencingError()
+	RecordPublishingError()
+	RecordDerivationError()
+	RecordReceivedUnsafePayload(payload *eth.ExecutionPayload)
+	recordRef(layer string, name string, num uint64, timestamp uint64, h common.Hash)
+	RecordL1Ref(name string, ref eth.L1BlockRef)
+	RecordL2Ref(name string, ref eth.L2BlockRef)
+	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
+	CountSequencedTxs(count int)
+	RecordL1ReorgDepth(d uint64)
+	RecordGossipEvent(evType int32)
+	IncPeerCount()
+	DecPeerCount()
+	IncStreamCount()
+	DecStreamCount()
+	RecordBandwidth(ctx context.Context, bwc *libp2pmetrics.BandwidthCounter)
+}
+
 type Metrics struct {
 	Info *prometheus.GaugeVec
 	Up   prometheus.Gauge
@@ -437,3 +463,78 @@ func (m *Metrics) Serve(ctx context.Context, hostname string, port int) error {
 	}()
 	return server.ListenAndServe()
 }
+
+type noopMetricer struct{}
+
+var NoopMetrics = new(noopMetricer)
+
+func (n *noopMetricer) RecordInfo(version string) {
+}
+
+func (n *noopMetricer) RecordUp() {
+}
+
+func (n *noopMetricer) RecordRPCServerRequest(method string) func() {
+	return func() {}
+}
+
+func (n *noopMetricer) RecordRPCClientRequest(method string) func(err error) {
+	return func(err error) {}
+}
+
+func (n *noopMetricer) RecordRPCClientResponse(method string, err error) {
+}
+
+func (n *noopMetricer) SetDerivationIdle(status bool) {
+}
+
+func (n *noopMetricer) RecordPipelineReset() {
+}
+
+func (n *noopMetricer) RecordSequencingError() {
+}
+
+func (n *noopMetricer) RecordPublishingError() {
+}
+
+func (n *noopMetricer) RecordDerivationError() {
+}
+
+func (n *noopMetricer) RecordReceivedUnsafePayload(payload *eth.ExecutionPayload) {
+}
+
+func (n *noopMetricer) recordRef(layer string, name string, num uint64, timestamp uint64, h common.Hash) {
+}
+
+func (n *noopMetricer) RecordL1Ref(name string, ref eth.L1BlockRef) {
+}
+
+func (n *noopMetricer) RecordL2Ref(name string, ref eth.L2BlockRef) {
+}
+
+func (n *noopMetricer) RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID) {
+}
+
+func (n *noopMetricer) CountSequencedTxs(count int) {
+}
+
+func (n *noopMetricer) RecordL1ReorgDepth(d uint64) {
+}
+
+func (n *noopMetricer) RecordGossipEvent(evType int32) {
+}
+
+func (n *noopMetricer) IncPeerCount() {
+}
+
+func (n *noopMetricer) DecPeerCount() {
+}
+
+func (n *noopMetricer) IncStreamCount() {
+}
+
+func (n *noopMetricer) DecStreamCount() {
+}
+
+func (n *noopMetricer) RecordBandwidth(ctx context.Context, bwc *libp2pmetrics.BandwidthCounter) {
+}

op-node/p2p/gossip.go

@@ -119,7 +119,7 @@ func BuildGlobalGossipParams(cfg *rollup.Config) pubsub.GossipSubParams {
 	return params
 }
 
-func NewGossipSub(p2pCtx context.Context, h host.Host, cfg *rollup.Config, r gossipMetrics) (*pubsub.PubSub, error) {
+func NewGossipSub(p2pCtx context.Context, h host.Host, cfg *rollup.Config, m GossipMetricer) (*pubsub.PubSub, error) {
 	denyList, err := pubsub.NewTimeCachedBlacklist(30 * time.Second)
 	if err != nil {
 		return nil, err
@@ -136,7 +136,7 @@ func NewGossipSub(p2pCtx context.Context, h host.Host, cfg *rollup.Config, r gos
 		pubsub.WithPeerExchange(false),
 		pubsub.WithBlacklist(denyList),
 		pubsub.WithGossipSubParams(BuildGlobalGossipParams(cfg)),
-		pubsub.WithEventTracer(&gossipTracer{r: r}),
+		pubsub.WithEventTracer(&gossipTracer{m: m}),
 	)
 	// TODO: pubsub.WithPeerScoreInspect(inspect, InspectInterval) to update peerstore scores with gossip scores
 }
@@ -448,11 +448,11 @@ func LogTopicEvents(ctx context.Context, log log.Logger, evHandler *pubsub.Topic
 }
 
 type gossipTracer struct {
-	r GossipMetricer
+	m GossipMetricer
 }
 
 func (g *gossipTracer) Trace(evt *pb.TraceEvent) {
-	if g.r != nil {
-		g.r.RecordGossipEvent(int32(*evt.Type))
+	if g.m != nil {
+		g.m.RecordGossipEvent(int32(*evt.Type))
 	}
 }

op-node/p2p/host_test.go

@@ -21,7 +21,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum-optimism/optimism/op-node/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/log"
@@ -132,7 +131,7 @@ func TestP2PFull(t *testing.T) {
 	// TODO: maybe swap the order of sec/mux preferences, to test that negotiation works
 
 	logA := testlog.Logger(t, log.LvlError).New("host", "A")
-	nodeA, err := NewNodeP2P(context.Background(), &rollup.Config{}, logA, &confA, &mockGossipIn{}, metrics.NewMetrics(""))
+	nodeA, err := NewNodeP2P(context.Background(), &rollup.Config{}, logA, &confA, &mockGossipIn{}, nil)
 	require.NoError(t, err)
 	defer nodeA.Close()
 
@@ -143,7 +142,7 @@ func TestP2PFull(t *testing.T) {
 			conns <- conn
 		}})
 
-	backend := NewP2PAPIBackend(nodeA, logA, metrics.NewMetrics(""))
+	backend := NewP2PAPIBackend(nodeA, logA, nil)
 	srv := rpc.NewServer()
 	require.NoError(t, srv.RegisterName("opp2p", backend))
 	client := rpc.DialInProc(srv)
@@ -155,7 +154,7 @@ func TestP2PFull(t *testing.T) {
 
 	logB := testlog.Logger(t, log.LvlError).New("host", "B")
 
-	nodeB, err := NewNodeP2P(context.Background(), &rollup.Config{}, logB, &confB, &mockGossipIn{}, metrics.NewMetrics(""))
+	nodeB, err := NewNodeP2P(context.Background(), &rollup.Config{}, logB, &confB, &mockGossipIn{}, nil)
 	require.NoError(t, err)
 	defer nodeB.Close()
 	hostB := nodeB.Host()
@@ -289,7 +288,7 @@ func TestDiscovery(t *testing.T) {
 	resourcesCtx, resourcesCancel := context.WithCancel(context.Background())
 	defer resourcesCancel()
 
-	nodeA, err := NewNodeP2P(context.Background(), rollupCfg, logA, &confA, &mockGossipIn{}, metrics.NewMetrics(""))
+	nodeA, err := NewNodeP2P(context.Background(), rollupCfg, logA, &confA, &mockGossipIn{}, nil)
 	require.NoError(t, err)
 	defer nodeA.Close()
 	hostA := nodeA.Host()
@@ -304,7 +303,7 @@ func TestDiscovery(t *testing.T) {
 	confB.DiscoveryDB = discDBC
 
 	// Start B
-	nodeB, err := NewNodeP2P(context.Background(), rollupCfg, logB, &confB, &mockGossipIn{}, metrics.NewMetrics(""))
+	nodeB, err := NewNodeP2P(context.Background(), rollupCfg, logB, &confB, &mockGossipIn{}, nil)
 	require.NoError(t, err)
 	defer nodeB.Close()
 	hostB := nodeB.Host()
@@ -319,7 +318,7 @@ func TestDiscovery(t *testing.T) {
 		}})
 
 	// Start C
-	nodeC, err := NewNodeP2P(context.Background(), rollupCfg, logC, &confC, &mockGossipIn{}, metrics.NewMetrics(""))
+	nodeC, err := NewNodeP2P(context.Background(), rollupCfg, logC, &confC, &mockGossipIn{}, nil)
 	require.NoError(t, err)
 	defer nodeC.Close()
 	hostC := nodeC.Host()

op-node/p2p/node.go

@@ -32,7 +32,7 @@ type NodeP2P struct {
 	gsOut    GossipOut        // p2p gossip application interface for publishing
 }
 
-func NewNodeP2P(resourcesCtx context.Context, rollupCfg *rollup.Config, log log.Logger, setup SetupP2P, gossipIn GossipIn, metrics *metrics.Metrics) (*NodeP2P, error) {
+func NewNodeP2P(resourcesCtx context.Context, rollupCfg *rollup.Config, log log.Logger, setup SetupP2P, gossipIn GossipIn, metrics metrics.Metricer) (*NodeP2P, error) {
 	if setup == nil {
 		return nil, errors.New("p2p node cannot be created without setup")
 	}
@@ -50,7 +50,7 @@ func NewNodeP2P(resourcesCtx context.Context, rollupCfg *rollup.Config, log log.
 	return &n, nil
 }
 
-func (n *NodeP2P) init(resourcesCtx context.Context, rollupCfg *rollup.Config, log log.Logger, setup SetupP2P, gossipIn GossipIn, metrics *metrics.Metrics) error {
+func (n *NodeP2P) init(resourcesCtx context.Context, rollupCfg *rollup.Config, log log.Logger, setup SetupP2P, gossipIn GossipIn, metrics metrics.Metricer) error {
 	bwc := p2pmetrics.NewBandwidthCounter()
 
 	var err error
@@ -95,7 +95,9 @@ func (n *NodeP2P) init(resourcesCtx context.Context, rollupCfg *rollup.Config, l
 			return fmt.Errorf("failed to start discv5: %w", err)
 		}
 
-		go metrics.RecordBandwidth(resourcesCtx, bwc)
+		if metrics != nil {
+			go metrics.RecordBandwidth(resourcesCtx, bwc)
+		}
 	}
 	return nil
 }

op-node/p2p/notifications.go

@@ -27,32 +27,27 @@ func (notif *notifications) ListenClose(n network.Network, a ma.Multiaddr) {
 	notif.log.Info("stopped listening network address", "addr", a)
 }
 func (notif *notifications) Connected(n network.Network, v network.Conn) {
-	if notif.m != nil {
-		notif.m.IncPeerCount()
-	}
+	notif.m.IncPeerCount()
 	notif.log.Info("connected to peer", "peer", v.RemotePeer(), "addr", v.RemoteMultiaddr())
 }
 func (notif *notifications) Disconnected(n network.Network, v network.Conn) {
-	if notif.m != nil {
-		notif.m.DecPeerCount()
-	}
+	notif.m.DecPeerCount()
 	notif.log.Info("disconnected from peer", "peer", v.RemotePeer(), "addr", v.RemoteMultiaddr())
 }
 func (notif *notifications) OpenedStream(n network.Network, v network.Stream) {
-	if notif.m != nil {
-		notif.m.IncStreamCount()
-	}
+	notif.m.IncStreamCount()
 	c := v.Conn()
 	notif.log.Trace("opened stream", "protocol", v.Protocol(), "peer", c.RemotePeer(), "addr", c.RemoteMultiaddr())
 }
 func (notif *notifications) ClosedStream(n network.Network, v network.Stream) {
-	if notif.m != nil {
-		notif.m.DecStreamCount()
-	}
+	notif.m.DecStreamCount()
 	c := v.Conn()
 	notif.log.Trace("opened stream", "protocol", v.Protocol(), "peer", c.RemotePeer(), "addr", c.RemoteMultiaddr())
 }
 
-func NewNetworkNotifier(log log.Logger, metrics *metrics.Metrics) network.Notifiee {
-	return &notifications{log: log, m: metrics}
+func NewNetworkNotifier(log log.Logger, m metrics.Metricer) network.Notifiee {
+	if m == nil {
+		m = metrics.NoopMetrics
+	}
+	return &notifications{log: log, m: m}
 }

op-node/p2p/rpc_server.go

@@ -54,12 +54,16 @@ type Node interface {
 type APIBackend struct {
 	node Node
 	log  log.Logger
-	m    *metrics.Metrics
+	m    metrics.Metricer
 }
 
 var _ API = (*APIBackend)(nil)
 
-func NewP2PAPIBackend(node Node, log log.Logger, m *metrics.Metrics) *APIBackend {
+func NewP2PAPIBackend(node Node, log log.Logger, m metrics.Metricer) *APIBackend {
+	if m == nil {
+		m = metrics.NoopMetrics
+	}
+
 	return &APIBackend{
 		node: node,
 		log:  log,