refactors

indexer/api/api.go

@@ -4,72 +4,113 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"runtime/debug"
+	"sync"
 
 	"github.com/ethereum-optimism/optimism/indexer/api/routes"
+	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-service/httputil"
 	"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"
+	"github.com/prometheus/client_golang/prometheus"
 )
 
 const ethereumAddressRegex = `^0x[a-fA-F0-9]{40}$`
 
 type Api struct {
-	log           log.Logger
-	Router        *chi.Mux
-	MetricsRouter *chi.Mux
+	log             log.Logger
+	Router          *chi.Mux
+	apiConfig       config.APIConfig
+	metricsConfig   config.MetricsConfig
+	metricsRegistry *prometheus.Registry
 }
 
 const (
 	MetricsNamespace = "op_indexer"
 )
 
-func NewApi(logger log.Logger, bv database.BridgeTransfersView) *Api {
+func ChiMetricsMiddleware(rec metrics.HTTPRecorder) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return metrics.NewHTTPRecordingMiddleware(rec, next)
+	}
+}
+
+func NewApi(logger log.Logger, bv database.BridgeTransfersView, apiConfig config.APIConfig, metricsConfig config.MetricsConfig) *Api {
 	apiRouter := chi.NewRouter()
 	h := routes.NewRoutes(logger, bv, apiRouter)
 
+	mr := metrics.NewRegistry()
+	promRecorder := metrics.NewPromHTTPRecorder(mr, MetricsNamespace)
+
+	apiRouter.Use(ChiMetricsMiddleware(promRecorder))
 	apiRouter.Use(middleware.Heartbeat("/healthz"))
 
 	apiRouter.Get(fmt.Sprintf("/api/v0/deposits/{address:%s}", ethereumAddressRegex), h.L1DepositsHandler)
 	apiRouter.Get(fmt.Sprintf("/api/v0/withdrawals/{address:%s}", ethereumAddressRegex), h.L2WithdrawalsHandler)
 
-	metricsRouter := chi.NewRouter()
-	registry := metrics.NewRegistry()
-	promRecorder := metrics.NewPromHTTPRecorder(registry, MetricsNamespace)
-	promHandler := metrics.NewHTTPRecordingMiddleware(promRecorder, apiRouter)
+	return &Api{log: logger, Router: apiRouter, metricsRegistry: mr, metricsConfig: metricsConfig, apiConfig: apiConfig}
+}
 
-	metricsRouter.Use(middleware.Heartbeat("/healthz"))
+func (a *Api) Start(ctx context.Context) error {
+	var wg sync.WaitGroup
+	errCh := make(chan error, 2)
+
+	processCtx, processCancel := context.WithCancel(ctx)
+	runProcess := func(start func(ctx context.Context) error) {
+		wg.Add(1)
+		go func() {
+			defer func() {
+				if err := recover(); err != nil {
+					a.log.Error("halting api on panic", "err", err)
+					debug.PrintStack()
+					errCh <- fmt.Errorf("panic: %v", err)
+				}
+
+				processCancel()
+				wg.Done()
+			}()
+
+			errCh <- start(processCtx)
+		}()
+	}
 
-	metricsRouter.Get("/metrics", promHandler.ServeHTTP)
+	runProcess(a.startServer)
+	runProcess(a.startMetricsServer)
 
-	return &Api{log: logger, Router: apiRouter, MetricsRouter: metricsRouter}
-}
+	wg.Wait()
 
-func (a *Api) Listen(ctx context.Context, port int) error {
-	a.log.Info("api server listening...", "port", port)
-	server := http.Server{Addr: fmt.Sprintf(":%d", port), Handler: a.Router}
-	err := httputil.ListenAndServeContext(ctx, &server)
+	err := <-errCh
 	if err != nil {
-		a.log.Error("api server stopped", "err", err)
+		a.log.Error("api stopped", "err", err)
 	} else {
-		a.log.Info("api server stopped")
+		a.log.Info("api stopped")
 	}
 
 	return err
 }
 
-func (a *Api) ListenMetrics(ctx context.Context, port int) error {
-	a.log.Info("metrics server listening...", "port", port)
-
-	server := http.Server{Addr: fmt.Sprintf(":%d", port), Handler: a.MetricsRouter}
+func (a *Api) startServer(ctx context.Context) error {
+	a.log.Info("api server listening...", "port", a.apiConfig.Port)
+	server := http.Server{Addr: fmt.Sprintf(":%d", a.apiConfig.Port), Handler: a.Router}
 	err := httputil.ListenAndServeContext(ctx, &server)
 	if err != nil {
 		a.log.Error("api server stopped", "err", err)
 	} else {
 		a.log.Info("api server stopped")
 	}
+	return err
+}
 
+func (a *Api) startMetricsServer(ctx context.Context) error {
+	a.log.Info("starting metrics server...", "port", a.metricsConfig.Port)
+	err := metrics.ListenAndServe(ctx, a.metricsRegistry, a.metricsConfig.Host, a.metricsConfig.Port)
+	if err != nil {
+		a.log.Error("metrics server stopped", "err", err)
+	} else {
+		a.log.Info("metrics server stopped")
+	}
 	return err
 }

indexer/api/api_test.go

@@ -6,6 +6,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
@@ -18,6 +19,15 @@ type MockBridgeTransfersView struct{}
 
 var mockAddress = "0x4204204204204204204204204204204204204204"
 
+var apiConfig = config.APIConfig{
+	Host: "localhost",
+	Port: 8080,
+}
+var metricsConfig = config.MetricsConfig{
+	Host: "localhost",
+	Port: 7300,
+}
+
 var (
 	deposit = database.L1BridgeDeposit{
 		TransactionSourceHash: common.HexToHash("abc"),
@@ -77,7 +87,7 @@ func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalsByAddress(address common.
 }
 func TestHealthz(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(logger, &MockBridgeTransfersView{})
+	api := NewApi(logger, &MockBridgeTransfersView{}, apiConfig, metricsConfig)
 	request, err := http.NewRequest("GET", "/healthz", nil)
 	assert.Nil(t, err)
 
@@ -89,7 +99,7 @@ func TestHealthz(t *testing.T) {
 
 func TestL1BridgeDepositsHandler(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(logger, &MockBridgeTransfersView{})
+	api := NewApi(logger, &MockBridgeTransfersView{}, apiConfig, metricsConfig)
 	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/deposits/%s", mockAddress), nil)
 	assert.Nil(t, err)
 
@@ -101,7 +111,7 @@ func TestL1BridgeDepositsHandler(t *testing.T) {
 
 func TestL2BridgeWithdrawalsByAddressHandler(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(logger, &MockBridgeTransfersView{})
+	api := NewApi(logger, &MockBridgeTransfersView{}, apiConfig, metricsConfig)
 	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/withdrawals/%s", mockAddress), nil)
 	assert.Nil(t, err)
 

indexer/cmd/indexer/cli.go

@@ -134,13 +134,6 @@ func runAll(ctx *cli.Context) error {
 			log.Error("indexer process non-zero exit", "err", err)
 		}
 	}()
-	go func() {
-		defer wg.Done()
-		err := runApiMetrics(ctx)
-		if err != nil {
-			log.Error("indexer process non-zero exit", "err", err)
-		}
-	}()
 
 	// We purposefully return no error since the indexer and api
 	// have no inter-dependencies. We simply rely on the logs to
@@ -161,7 +154,7 @@ func newCli(GitCommit string, GitDate string) *cli.App {
 				Name:        "api",
 				Flags:       flags,
 				Description: "Runs the api service",
-				Action:      runApiAndMetrics,
+				Action:      runApi,
 			},
 			{
 				Name:        "index",