Add healthcheck to archiver service

danyalprout · danyalprout · commit a4cb75753047 · 2024-02-11T12:56:37.000-06:00
diff --git a/api/cmd/main.go b/api/cmd/main.go
@@ -13,7 +13,6 @@ import (
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	"github.com/ethereum-optimism/optimism/op-service/cliapp"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
-	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 )
@@ -54,8 +53,7 @@ func Main() cliapp.LifecycleAction {
 		oplog.SetGlobalLogHandler(l.GetHandler())
 		opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 
-		registry := opmetrics.NewRegistry()
-		m := metrics.NewMetrics(registry)
+		m := metrics.NewMetrics()
 
 		storageClient, err := storage.NewStorage(cfg.StorageConfig, l)
 		if err != nil {
@@ -68,6 +66,7 @@ func Main() cliapp.LifecycleAction {
 		}
 
 		l.Info("Initializing API Service")
-		return service.NewAPIService(l, storageClient, beaconClient, cfg, registry, m), nil
+		api := service.NewAPI(storageClient, beaconClient, m, l)
+		return service.NewService(l, api, cfg, m.Registry()), nil
 	}
 }
diff --git a/api/metrics/metrics.go b/api/metrics/metrics.go
@@ -2,6 +2,7 @@ package metrics
 
 import (
 	"github.com/ethereum-optimism/optimism/op-service/metrics"
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
@@ -16,16 +17,20 @@ var (
 )
 
 type Metricer interface {
+	Registry() *prometheus.Registry
 	RecordBlockIdType(t BlockIdType)
 }
 
 type metricsRecorder struct {
 	inputType *prometheus.CounterVec
+	registry  *prometheus.Registry
 }
 
-func NewMetrics(registry *prometheus.Registry) Metricer {
+func NewMetrics() Metricer {
+	registry := opmetrics.NewRegistry()
 	factory := metrics.With(registry)
 	return &metricsRecorder{
+		registry: registry,
 		inputType: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: MetricsNamespace,
 			Name:      "block_id_type",
@@ -37,3 +42,7 @@ func NewMetrics(registry *prometheus.Registry) Metricer {
 func (m *metricsRecorder) RecordBlockIdType(t BlockIdType) {
 	m.inputType.WithLabelValues(string(t)).Inc()
 }
+
+func (m *metricsRecorder) Registry() *prometheus.Registry {
+	return m.registry
+}
diff --git a/api/service/api.go b/api/service/api.go
@@ -22,7 +22,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
-	"github.com/prometheus/client_golang/prometheus"
 )
 
 type httpError struct {
@@ -77,7 +76,7 @@ type API struct {
 	metrics         m.Metricer
 }
 
-func NewAPI(dataStoreClient storage.DataStoreReader, beaconClient client.BeaconBlockHeadersProvider, metrics m.Metricer, registry *prometheus.Registry, logger log.Logger) *API {
+func NewAPI(dataStoreClient storage.DataStoreReader, beaconClient client.BeaconBlockHeadersProvider, metrics m.Metricer, logger log.Logger) *API {
 	result := &API{
 		dataStoreClient: dataStoreClient,
 		beaconClient:    beaconClient,
@@ -92,7 +91,7 @@ func NewAPI(dataStoreClient storage.DataStoreReader, beaconClient client.BeaconB
 	r.Use(middleware.Recoverer)
 	r.Use(middleware.Heartbeat("/healthz"))
 
-	recorder := opmetrics.NewPromHTTPRecorder(registry, m.MetricsNamespace)
+	recorder := opmetrics.NewPromHTTPRecorder(metrics.Registry(), m.MetricsNamespace)
 	r.Use(func(handler http.Handler) http.Handler {
 		return opmetrics.NewHTTPRecordingMiddleware(recorder, handler)
 	})
diff --git a/api/service/api_test.go b/api/service/api_test.go
@@ -16,7 +16,6 @@ import (
 	"github.com/base-org/blob-archiver/common/beacon/beacontest"
 	"github.com/base-org/blob-archiver/common/blobtest"
 	"github.com/base-org/blob-archiver/common/storage"
-	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -58,10 +57,9 @@ func setup(t *testing.T) (*API, *storage.FileStorage, *beacontest.StubBeaconClie
 	require.NoError(t, err)
 	fs := storage.NewFileStorage(tempDir, logger)
 	beacon := beacontest.NewEmptyStubBeaconClient()
-	r := opmetrics.NewRegistry()
-	m := metrics.NewMetrics(r)
-	api := NewAPI(fs, beacon, m, r, logger)
-	return api, fs, beacon, func() {
+	m := metrics.NewMetrics()
+	a := NewAPI(fs, beacon, m, logger)
+	return a, fs, beacon, func() {
 		require.NoError(t, os.RemoveAll(tempDir))
 	}
 }
diff --git a/api/service/service.go b/api/service/service.go
@@ -6,10 +6,7 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	client "github.com/attestantio/go-eth2-client"
 	"github.com/base-org/blob-archiver/api/flags"
-	"github.com/base-org/blob-archiver/api/metrics"
-	"github.com/base-org/blob-archiver/common/storage"
 	"github.com/ethereum-optimism/optimism/op-service/httputil"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum/go-ethereum/log"
@@ -18,13 +15,12 @@ import (
 
 var ErrAlreadyStopped = errors.New("already stopped")
 
-func NewAPIService(l log.Logger, dataStoreClient storage.DataStoreReader, beaconClient client.BeaconBlockHeadersProvider, cfg flags.APIConfig, registry *prometheus.Registry, m metrics.Metricer) *APIService {
-	router := NewAPI(dataStoreClient, beaconClient, m, registry, l)
+func NewService(l log.Logger, api *API, cfg flags.APIConfig, registry *prometheus.Registry) *APIService {
 	return &APIService{
 		log:      l,
 		cfg:      cfg,
 		registry: registry,
-		router:   router,
+		api:      api,
 	}
 }
 
@@ -35,7 +31,7 @@ type APIService struct {
 	registry      *prometheus.Registry
 	metricsServer *httputil.HTTPServer
 	apiServer     *httputil.HTTPServer
-	router        *API
+	api           *API
 }
 
 func (a *APIService) Start(ctx context.Context) error {
@@ -52,7 +48,7 @@ func (a *APIService) Start(ctx context.Context) error {
 
 	a.log.Debug("starting API server", "address", a.cfg.ListenAddr)
 
-	srv, err := httputil.StartHTTPServer(a.cfg.ListenAddr, a.router.router)
+	srv, err := httputil.StartHTTPServer(a.cfg.ListenAddr, a.api.router)
 	if err != nil {
 		return fmt.Errorf("failed to start API server: %w", err)
 	}
diff --git a/archiver/cmd/main.go b/archiver/cmd/main.go
@@ -13,7 +13,6 @@ import (
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	"github.com/ethereum-optimism/optimism/op-service/cliapp"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
-	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 )
@@ -55,8 +54,7 @@ func Main() cliapp.LifecycleAction {
 		oplog.SetGlobalLogHandler(l.GetHandler())
 		opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 
-		registry := opmetrics.NewRegistry()
-		m := metrics.NewMetrics(registry)
+		m := metrics.NewMetrics()
 
 		beaconClient, err := beacon.NewBeaconClient(context.Background(), cfg.BeaconConfig)
 		if err != nil {
@@ -69,6 +67,6 @@ func Main() cliapp.LifecycleAction {
 		}
 
 		l.Info("Initializing Archiver Service")
-		return service.NewArchiverService(l, cfg, storageClient, beaconClient, m, registry)
+		return service.NewService(l, cfg, storageClient, beaconClient, m)
 	}
 }
diff --git a/archiver/metrics/metrics.go b/archiver/metrics/metrics.go
@@ -2,44 +2,53 @@ package metrics
 
 import (
 	"github.com/ethereum-optimism/optimism/op-service/metrics"
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 type BlockSource string
 
 var (
-	metricsNamespace = "blob_archiver"
+	MetricsNamespace = "blob_archiver"
 
 	BlockSourceBackfill BlockSource = "backfill"
 	BlockSourceLive     BlockSource = "live"
 )
 
 type Metricer interface {
+	Registry() *prometheus.Registry
 	RecordProcessedBlock(source BlockSource)
 	RecordStoredBlobs(count int)
 }
 
 type metricsRecorder struct {
 	blockProcessedCounter *prometheus.CounterVec
 	blobsStored           prometheus.Counter
+	registry              *prometheus.Registry
 }
 
-func NewMetrics(registry *prometheus.Registry) Metricer {
+func NewMetrics() Metricer {
+	registry := opmetrics.NewRegistry()
 	factory := metrics.With(registry)
 	return &metricsRecorder{
+		registry: registry,
 		blockProcessedCounter: factory.NewCounterVec(prometheus.CounterOpts{
-			Namespace: metricsNamespace,
+			Namespace: MetricsNamespace,
 			Name:      "blocks_processed",
 			Help:      "number of times processing loop has run",
 		}, []string{"source"}),
 		blobsStored: factory.NewCounter(prometheus.CounterOpts{
-			Namespace: metricsNamespace,
+			Namespace: MetricsNamespace,
 			Name:      "blobs_stored",
 			Help:      "number of blobs stored",
 		}),
 	}
 }
 
+func (m *metricsRecorder) Registry() *prometheus.Registry {
+	return m.registry
+}
+
 func (m *metricsRecorder) RecordStoredBlobs(count int) {
 	m.blobsStored.Add(float64(count))
 }
diff --git a/archiver/service/api.go b/archiver/service/api.go
@@ -0,0 +1,45 @@
+package service
+
+import (
+	"net/http"
+	"time"
+
+	m "github.com/base-org/blob-archiver/archiver/metrics"
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+const (
+	serverTimeout = 60 * time.Second
+)
+
+type API struct {
+	router  *chi.Mux
+	logger  log.Logger
+	metrics m.Metricer
+}
+
+func NewAPI(metrics m.Metricer, logger log.Logger) *API {
+	result := &API{
+		router:  chi.NewRouter(),
+		logger:  logger,
+		metrics: metrics,
+	}
+
+	r := result.router
+	r.Use(middleware.Logger)
+	r.Use(middleware.Timeout(serverTimeout))
+	r.Use(middleware.Recoverer)
+	r.Use(middleware.Heartbeat("/healthz"))
+
+	recorder := opmetrics.NewPromHTTPRecorder(metrics.Registry(), m.MetricsNamespace)
+	r.Use(func(handler http.Handler) http.Handler {
+		return opmetrics.NewHTTPRecordingMiddleware(recorder, handler)
+	})
+
+	r.Get("/", http.NotFound)
+
+	return result
+}
diff --git a/archiver/service/api_test.go b/archiver/service/api_test.go
@@ -0,0 +1,28 @@
+package service
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/base-org/blob-archiver/archiver/metrics"
+	"github.com/ethereum-optimism/optimism/op-service/testlog"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/stretchr/testify/require"
+)
+
+func setupAPI(t *testing.T) *API {
+	logger := testlog.Logger(t, log.LvlInfo)
+	m := metrics.NewMetrics()
+	return NewAPI(m, logger)
+}
+
+func TestHealthHandler(t *testing.T) {
+	a := setupAPI(t)
+
+	request := httptest.NewRequest("GET", "/healthz", nil)
+	response := httptest.NewRecorder()
+
+	a.router.ServeHTTP(response, request)
+
+	require.Equal(t, 200, response.Code)
+}
diff --git a/archiver/service/archiver.go b/archiver/service/archiver.go
@@ -16,7 +16,6 @@ import (
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/prometheus/client_golang/prometheus"
 )
 
 const backfillErrorRetryInterval = 5 * time.Second
@@ -28,11 +27,10 @@ type BeaconClient interface {
 	client.BeaconBlockHeadersProvider
 }
 
-func NewArchiverService(l log.Logger, cfg flags.ArchiverConfig, dataStoreClient storage.DataStore, client BeaconClient, m metrics.Metricer, registry *prometheus.Registry) (*ArchiverService, error) {
+func NewService(l log.Logger, cfg flags.ArchiverConfig, dataStoreClient storage.DataStore, client BeaconClient, m metrics.Metricer) (*ArchiverService, error) {
 	return &ArchiverService{
 		log:             l,
 		cfg:             cfg,
-		registry:        registry,
 		dataStoreClient: dataStoreClient,
 		metrics:         m,
 		stopCh:          make(chan struct{}),
@@ -46,7 +44,6 @@ type ArchiverService struct {
 	log             log.Logger
 	dataStoreClient storage.DataStore
 	beaconClient    BeaconClient
-	registry        *prometheus.Registry
 	metricsServer   *httputil.HTTPServer
 	cfg             flags.ArchiverConfig
 	metrics         metrics.Metricer
@@ -55,7 +52,7 @@ type ArchiverService struct {
 func (a *ArchiverService) Start(ctx context.Context) error {
 	if a.cfg.MetricsConfig.Enabled {
 		a.log.Info("starting metrics server", "addr", a.cfg.MetricsConfig.ListenAddr, "port", a.cfg.MetricsConfig.ListenPort)
-		srv, err := opmetrics.StartServer(a.registry, a.cfg.MetricsConfig.ListenAddr, a.cfg.MetricsConfig.ListenPort)
+		srv, err := opmetrics.StartServer(a.metrics.Registry(), a.cfg.MetricsConfig.ListenAddr, a.cfg.MetricsConfig.ListenPort)
 		if err != nil {
 			return err
 		}
diff --git a/archiver/service/archiver_test.go b/archiver/service/archiver_test.go
@@ -14,19 +14,17 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/require"
 )
 
 func setup(t *testing.T, beacon *beacontest.StubBeaconClient) (*ArchiverService, *storagetest.TestFileStorage) {
 	l := testlog.Logger(t, log.LvlInfo)
 	fs := storagetest.NewTestFileStorage(t, l)
-	registry := prometheus.NewRegistry()
-	m := metrics.NewMetrics(registry)
-	svc, err := NewArchiverService(l, flags.ArchiverConfig{
+	m := metrics.NewMetrics()
+	svc, err := NewService(l, flags.ArchiverConfig{
 		PollInterval: 5 * time.Second,
 		OriginBlock:  blobtest.OriginBlock,
-	}, fs, beacon, m, registry)
+	}, fs, beacon, m)
 	require.NoError(t, err)
 	return svc, fs
 }

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,6 @@ import (`
`13`	`13`	`opservice "github.com/ethereum-optimism/optimism/op-service"`
`14`	`14`	`"github.com/ethereum-optimism/optimism/op-service/cliapp"`
`15`	`15`	`oplog "github.com/ethereum-optimism/optimism/op-service/log"`
`16`		`- opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"`
`17`	`16`	`"github.com/ethereum/go-ethereum/log"`
`18`	`17`	`"github.com/urfave/cli/v2"`
`19`	`18`	`)`
`@@ -54,8 +53,7 @@ func Main() cliapp.LifecycleAction {`
`54`	`53`	`oplog.SetGlobalLogHandler(l.GetHandler())`
`55`	`54`	`opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)`
`56`	`55`
`57`		`- registry := opmetrics.NewRegistry()`
`58`		`- m := metrics.NewMetrics(registry)`
	`56`	`+ m := metrics.NewMetrics()`
`59`	`57`
`60`	`58`	`storageClient, err := storage.NewStorage(cfg.StorageConfig, l)`
`61`	`59`	`if err != nil {`
`@@ -68,6 +66,7 @@ func Main() cliapp.LifecycleAction {`
`68`	`66`	`}`
`69`	`67`
`70`	`68`	`l.Info("Initializing API Service")`
`71`		`- return service.NewAPIService(l, storageClient, beaconClient, cfg, registry, m), nil`
	`69`	`+ api := service.NewAPI(storageClient, beaconClient, m, l)`
	`70`	`+ return service.NewService(l, api, cfg, m.Registry()), nil`
`72`	`71`	`}`
`73`	`72`	`}`