feat: fix conflict

common/go.mod

@@ -128,4 +128,4 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	gotest.tools/v3 v3.4.0 // indirect
-)
+)

common/metrics/ginmetrics/bloom.go

@@ -0,0 +1,57 @@
+package ginmetrics
+
+import (
+	"github.com/bits-and-blooms/bitset"
+)
+
+const defaultSize = 2 << 24
+
+var seeds = []uint{7, 11, 13, 31, 37, 61}
+
+// BloomFilter a simple bloom filter
+type BloomFilter struct {
+	Set   *bitset.BitSet
+	Funcs [6]simpleHash
+}
+
+// NewBloomFilter new a BloomFilter
+func NewBloomFilter() *BloomFilter {
+	bf := new(BloomFilter)
+	for i := 0; i < len(bf.Funcs); i++ {
+		bf.Funcs[i] = simpleHash{defaultSize, seeds[i]}
+	}
+	bf.Set = bitset.New(defaultSize)
+	return bf
+}
+
+// Add a value to BloomFilter
+func (bf *BloomFilter) Add(value string) {
+	for _, f := range bf.Funcs {
+		bf.Set.Set(f.hash(value))
+	}
+}
+
+// Contains check the value is in bloom filter
+func (bf *BloomFilter) Contains(value string) bool {
+	if value == "" {
+		return false
+	}
+	ret := true
+	for _, f := range bf.Funcs {
+		ret = ret && bf.Set.Test(f.hash(value))
+	}
+	return ret
+}
+
+type simpleHash struct {
+	Cap  uint
+	Seed uint
+}
+
+func (s *simpleHash) hash(value string) uint {
+	var result uint = 0
+	for i := 0; i < len(value); i++ {
+		result = result*s.Seed + uint(value[i])
+	}
+	return (s.Cap - 1) & result
+}

common/metrics/ginmetrics/metric.go

@@ -0,0 +1,89 @@
+package ginmetrics
+
+import (
+	"fmt"
+
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// Metric defines a metric object. Users can use it to save
+// metric data. Every metric should be globally unique by name.
+type Metric struct {
+	Type        MetricType
+	Name        string
+	Description string
+	Labels      []string
+	Buckets     []float64
+	Objectives  map[float64]float64
+
+	vec prometheus.Collector
+}
+
+// SetGaugeValue set data for Gauge type Metric.
+func (m *Metric) SetGaugeValue(labelValues []string, value float64) error {
+	if m.Type == None {
+		return fmt.Errorf("metric %s not existed", m.Name)
+	}
+
+	if m.Type != Gauge {
+		return fmt.Errorf("metric %s not Gauge type", m.Name)
+	}
+	m.vec.(*prometheus.GaugeVec).WithLabelValues(labelValues...).Set(value)
+	return nil
+}
+
+// Inc increases value for Counter/Gauge type metric, increments
+// the counter by 1
+func (m *Metric) Inc(labelValues []string) error {
+	if m.Type == None {
+		return fmt.Errorf("metric %s not existed", m.Name)
+	}
+
+	if m.Type != Gauge && m.Type != Counter {
+		return fmt.Errorf("metric %s not Gauge or Counter type", m.Name)
+	}
+	switch m.Type {
+	case Counter:
+		m.vec.(*prometheus.CounterVec).WithLabelValues(labelValues...).Inc()
+	case Gauge:
+		m.vec.(*prometheus.GaugeVec).WithLabelValues(labelValues...).Inc()
+	}
+	return nil
+}
+
+// Add adds the given value to the Metric object. Only
+// for Counter/Gauge type metric.
+func (m *Metric) Add(labelValues []string, value float64) error {
+	if m.Type == None {
+		return fmt.Errorf("metric %s not existed", m.Name)
+	}
+
+	if m.Type != Gauge && m.Type != Counter {
+		return fmt.Errorf("metric %s not Gauge or Counter type", m.Name)
+	}
+	switch m.Type {
+	case Counter:
+		m.vec.(*prometheus.CounterVec).WithLabelValues(labelValues...).Add(value)
+	case Gauge:
+		m.vec.(*prometheus.GaugeVec).WithLabelValues(labelValues...).Add(value)
+	}
+	return nil
+}
+
+// Observe is used by Histogram and Summary type metric to
+// add observations.
+func (m *Metric) Observe(labelValues []string, value float64) error {
+	if m.Type == 0 {
+		return fmt.Errorf("metric %s not existed", m.Name)
+	}
+	if m.Type != Histogram && m.Type != Summary {
+		return fmt.Errorf("metric %s not Histogram or Summary type", m.Name)
+	}
+	switch m.Type {
+	case Histogram:
+		m.vec.(*prometheus.HistogramVec).WithLabelValues(labelValues...).Observe(value)
+	case Summary:
+		m.vec.(*prometheus.SummaryVec).WithLabelValues(labelValues...).Observe(value)
+	}
+	return nil
+}

common/metrics/ginmetrics/middleware.go

@@ -0,0 +1,155 @@
+package ginmetrics
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+var (
+	metricRequestTotal    = "request_total"
+	metricRequestUVTotal  = "request_uv_total"
+	metricURIRequestTotal = "uri_request_total"
+	metricRequestBody     = "request_body_total"
+	metricResponseBody    = "response_body_total"
+	metricRequestDuration = "request_duration"
+	metricSlowRequest     = "slow_request_total"
+
+	bloomFilter *BloomFilter
+)
+
+// Use set gin metrics middleware
+func (m *Monitor) Use(r gin.IRoutes) {
+	m.initGinMetrics()
+
+	r.Use(m.monitorInterceptor)
+	r.GET(m.metricPath, func(ctx *gin.Context) {
+		promhttp.Handler().ServeHTTP(ctx.Writer, ctx.Request)
+	})
+}
+
+// UseWithoutExposingEndpoint is used to add monitor interceptor to gin router
+// It can be called multiple times to intercept from multiple gin.IRoutes
+// http path is not set, to do that use Expose function
+func (m *Monitor) UseWithoutExposingEndpoint(r gin.IRoutes) {
+	m.initGinMetrics()
+	r.Use(m.monitorInterceptor)
+}
+
+// Expose adds metric path to a given router.
+// The router can be different with the one passed to UseWithoutExposingEndpoint.
+// This allows to expose metrics on different port.
+func (m *Monitor) Expose(r gin.IRoutes) {
+	r.GET(m.metricPath, func(ctx *gin.Context) {
+		promhttp.Handler().ServeHTTP(ctx.Writer, ctx.Request)
+	})
+}
+
+// initGinMetrics used to init gin metrics
+func (m *Monitor) initGinMetrics() {
+	bloomFilter = NewBloomFilter()
+
+	_ = monitor.AddMetric(&Metric{
+		Type:        Counter,
+		Name:        metricRequestTotal,
+		Description: "all the server received request num.",
+		Labels:      nil,
+	})
+	_ = monitor.AddMetric(&Metric{
+		Type:        Counter,
+		Name:        metricRequestUVTotal,
+		Description: "all the server received ip num.",
+		Labels:      nil,
+	})
+	_ = monitor.AddMetric(&Metric{
+		Type:        Counter,
+		Name:        metricURIRequestTotal,
+		Description: "all the server received request num with every uri.",
+		Labels:      []string{"uri", "method", "code"},
+	})
+	_ = monitor.AddMetric(&Metric{
+		Type:        Counter,
+		Name:        metricRequestBody,
+		Description: "the server received request body size, unit byte",
+		Labels:      nil,
+	})
+	_ = monitor.AddMetric(&Metric{
+		Type:        Counter,
+		Name:        metricResponseBody,
+		Description: "the server send response body size, unit byte",
+		Labels:      nil,
+	})
+	_ = monitor.AddMetric(&Metric{
+		Type:        Histogram,
+		Name:        metricRequestDuration,
+		Description: "the time server took to handle the request.",
+		Labels:      []string{"uri"},
+		Buckets:     m.reqDuration,
+	})
+	_ = monitor.AddMetric(&Metric{
+		Type:        Counter,
+		Name:        metricSlowRequest,
+		Description: fmt.Sprintf("the server handled slow requests counter, t=%d.", m.slowTime),
+		Labels:      []string{"uri", "method", "code"},
+	})
+}
+
+// monitorInterceptor as gin monitor middleware.
+func (m *Monitor) monitorInterceptor(ctx *gin.Context) {
+	if ctx.Request.URL.Path == m.metricPath {
+		ctx.Next()
+		return
+	}
+	startTime := time.Now()
+
+	// execute normal process.
+	ctx.Next()
+
+	// after request
+	m.ginMetricHandle(ctx, startTime)
+}
+
+func (m *Monitor) ginMetricHandle(ctx *gin.Context, start time.Time) {
+	r := ctx.Request
+	w := ctx.Writer
+
+	//set request total
+	_ = m.GetMetric(metricRequestTotal).Inc(nil)
+
+	// set uv
+	if clientIP := ctx.ClientIP(); !bloomFilter.Contains(clientIP) {
+		bloomFilter.Add(clientIP)
+		_ = m.GetMetric(metricRequestUVTotal).Inc(nil)
+	}
+
+	errCode := strconv.Itoa(ctx.GetInt("errcode"))
+	if len(errCode) == 0 {
+		errCode = strconv.Itoa(w.Status())
+	}
+
+	// set uri request total
+	_ = m.GetMetric(metricURIRequestTotal).Inc([]string{ctx.FullPath(), r.Method, errCode})
+
+	// set request body size
+	// since r.ContentLength can be negative (in some occasions) guard the operation
+	if r.ContentLength >= 0 {
+		_ = m.GetMetric(metricRequestBody).Add(nil, float64(r.ContentLength))
+	}
+
+	// set slow request
+	latency := time.Since(start)
+	if int32(latency.Seconds()) > m.slowTime {
+		_ = m.GetMetric(metricSlowRequest).Inc([]string{ctx.FullPath(), r.Method, strconv.Itoa(w.Status())})
+	}
+
+	// set request duration
+	_ = m.GetMetric(metricRequestDuration).Observe([]string{ctx.FullPath()}, latency.Seconds())
+
+	// set response size
+	if w.Size() > 0 {
+		_ = m.GetMetric(metricResponseBody).Add(nil, float64(w.Size()))
+	}
+}

common/metrics/ginmetrics/types.go

@@ -0,0 +1,158 @@
+package ginmetrics
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+// MetricType define metric type
+type MetricType int
+
+const (
+	// None unknown metric type
+	None MetricType = iota
+	// Counter MetricType
+	Counter
+	// Gauge MetricType
+	Gauge
+	// Histogram MetricType
+	Histogram
+	// Summary MetricType
+	Summary
+
+	defaultMetricPath = "/debug/metrics"
+	defaultSlowTime   = int32(5)
+)
+
+var (
+	defaultDuration = []float64{0.1, 0.3, 1.2, 5, 10}
+	monitor         *Monitor
+
+	promTypeHandler = map[MetricType]func(metric *Metric, reg prometheus.Registerer){
+		Counter:   counterHandler,
+		Gauge:     gaugeHandler,
+		Histogram: histogramHandler,
+		Summary:   summaryHandler,
+	}
+)
+
+// Monitor is an object that uses to set gin server monitor.
+type Monitor struct {
+	slowTime    int32
+	metricPath  string
+	reqDuration []float64
+	metrics     map[string]*Metric
+	register    prometheus.Registerer
+}
+
+// GetMonitor used to get global Monitor object,
+// this function returns a singleton object.
+func GetMonitor(reg prometheus.Registerer) *Monitor {
+	if monitor == nil {
+		monitor = &Monitor{
+			metricPath:  defaultMetricPath,
+			slowTime:    defaultSlowTime,
+			reqDuration: defaultDuration,
+			metrics:     make(map[string]*Metric),
+			register:    reg,
+		}
+	}
+	return monitor
+}
+
+// GetMetric used to get metric object by metric_name.
+func (m *Monitor) GetMetric(name string) *Metric {
+	if metric, ok := m.metrics[name]; ok {
+		return metric
+	}
+	return &Metric{}
+}
+
+// SetMetricPath set metricPath property. metricPath is used for Prometheus
+// to get gin server monitoring data.
+func (m *Monitor) SetMetricPath(path string) {
+	m.metricPath = path
+}
+
+// SetSlowTime set slowTime property. slowTime is used to determine whether
+// the request is slow. For "gin_slow_request_total" metric.
+func (m *Monitor) SetSlowTime(slowTime int32) {
+	m.slowTime = slowTime
+}
+
+// SetDuration set reqDuration property. reqDuration is used to ginRequestDuration
+// metric buckets.
+func (m *Monitor) SetDuration(duration []float64) {
+	m.reqDuration = duration
+}
+
+// SetMetricPrefix set the metric prefix
+func (m *Monitor) SetMetricPrefix(prefix string) {
+	metricRequestTotal = prefix + metricRequestTotal
+	metricRequestUVTotal = prefix + metricRequestUVTotal
+	metricURIRequestTotal = prefix + metricURIRequestTotal
+	metricRequestBody = prefix + metricRequestBody
+	metricResponseBody = prefix + metricResponseBody
+	metricRequestDuration = prefix + metricRequestDuration
+	metricSlowRequest = prefix + metricSlowRequest
+}
+
+// SetMetricSuffix set the metric suffix
+func (m *Monitor) SetMetricSuffix(suffix string) {
+	metricRequestTotal += suffix
+	metricRequestUVTotal += suffix
+	metricURIRequestTotal += suffix
+	metricRequestBody += suffix
+	metricResponseBody += suffix
+	metricRequestDuration += suffix
+	metricSlowRequest += suffix
+}
+
+// AddMetric add custom monitor metric.
+func (m *Monitor) AddMetric(metric *Metric) error {
+	if _, ok := m.metrics[metric.Name]; ok {
+		return fmt.Errorf("metric %s is existed", metric.Name)
+	}
+
+	if metric.Name == "" {
+		return errors.New("metric name cannot be empty")
+	}
+
+	if f, ok := promTypeHandler[metric.Type]; ok {
+		f(metric, m.register)
+		m.metrics[metric.Name] = metric
+	}
+
+	return nil
+}
+
+func counterHandler(metric *Metric, register prometheus.Registerer) {
+	metric.vec = promauto.With(register).NewCounterVec(
+		prometheus.CounterOpts{Name: metric.Name, Help: metric.Description},
+		metric.Labels,
+	)
+}
+
+func gaugeHandler(metric *Metric, register prometheus.Registerer) {
+	metric.vec = promauto.With(register).NewGaugeVec(
+		prometheus.GaugeOpts{Name: metric.Name, Help: metric.Description},
+		metric.Labels,
+	)
+}
+
+func histogramHandler(metric *Metric, register prometheus.Registerer) {
+	metric.vec = promauto.With(register).NewHistogramVec(
+		prometheus.HistogramOpts{Name: metric.Name, Help: metric.Description, Buckets: metric.Buckets},
+		metric.Labels,
+	)
+}
+
+func summaryHandler(metric *Metric, register prometheus.Registerer) {
+	promauto.With(register).NewSummaryVec(
+		prometheus.SummaryOpts{Name: metric.Name, Help: metric.Description, Objectives: metric.Objectives},
+		metric.Labels,
+	)
+}

common/metrics/middleware.go

@@ -0,0 +1,18 @@
+package metrics
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/prometheus/client_golang/prometheus"
+
+	"scroll-tech/common/metrics/ginmetrics"
+)
+
+// Use register the gin metric
+func Use(router *gin.Engine, metricsPrefix string, reg prometheus.Registerer) {
+	m := ginmetrics.GetMonitor(reg)
+	m.SetMetricPath("/metrics")
+	m.SetMetricPrefix(metricsPrefix + "_")
+	m.SetSlowTime(1)
+	m.SetDuration([]float64{0.025, .05, .1, .5, 1, 5, 10})
+	m.UseWithoutExposingEndpoint(router)
+}

common/metrics/server.go

@@ -0,0 +1,33 @@
+package metrics
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+
+	"scroll-tech/common/utils"
+)
+
+// Server starts the metrics server on the given address, will be closed when the given
+// context is canceled.
+func Server(c *cli.Context, reg *prometheus.Registry) {
+	if !c.Bool(utils.MetricsEnabled.Name) {
+		return
+	}
+
+	address := fmt.Sprintf(":%s", c.String(utils.MetricsPort.Name))
+
+	log.Info("Starting metrics server", "address", address)
+
+	http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg}))
+	go func() {
+		if runServerErr := http.ListenAndServe(address, nil); runServerErr != nil && !errors.Is(runServerErr, http.ErrServerClosed) {
+			log.Crit("run metrics http server failure", "error", runServerErr)
+		}
+	}()
+}

common/version/version.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 )
 
-var tag = "v4.1.38"
+var tag = "v4.1.39"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/cmd/app/app.go

@@ -16,8 +16,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
+	"gorm.io/gorm"
 
 	"scroll-tech/common/database"
+	"scroll-tech/common/metrics"
 	"scroll-tech/common/utils"
 	"scroll-tech/common/version"
 
@@ -59,6 +61,7 @@ func action(ctx *cli.Context) error {
 	}
 
 	registry := prometheus.DefaultRegisterer
+	metrics.Server(ctx, registry.(*prometheus.Registry))
 
 	proofCollector := cron.NewCollector(subCtx, db, cfg, registry)
 	defer func() {
@@ -69,21 +72,7 @@ func action(ctx *cli.Context) error {
 		}
 	}()
 
-	router := gin.New()
-	api.InitController(cfg, db, registry)
-	route.Route(router, cfg, registry)
-	port := ctx.String(httpPortFlag.Name)
-	srv := &http.Server{
-		Addr:              fmt.Sprintf(":%s", port),
-		Handler:           router,
-		ReadHeaderTimeout: time.Minute,
-	}
-
-	go func() {
-		if runServerErr := srv.ListenAndServe(); err != nil && !errors.Is(runServerErr, http.ErrServerClosed) {
-			log.Crit("run coordinator http server failure", "error", runServerErr)
-		}
-	}()
+	apiSrv := apiServer(ctx, cfg, db, registry)
 
 	// Catch CTRL-C to ensure a graceful shutdown.
 	interrupt := make(chan os.Signal, 1)
@@ -95,7 +84,7 @@ func action(ctx *cli.Context) error {
 
 	closeCtx, cancelExit := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancelExit()
-	if err = srv.Shutdown(closeCtx); err != nil {
+	if err = apiSrv.Shutdown(closeCtx); err != nil {
 		log.Warn("shutdown coordinator server failure", "error", err)
 		return nil
 	}
@@ -105,6 +94,25 @@ func action(ctx *cli.Context) error {
 	return nil
 }
 
+func apiServer(ctx *cli.Context, cfg *config.Config, db *gorm.DB, reg prometheus.Registerer) *http.Server {
+	router := gin.New()
+	api.InitController(cfg, db, reg)
+	route.Route(router, cfg, reg)
+	port := ctx.String(httpPortFlag.Name)
+	srv := &http.Server{
+		Addr:              fmt.Sprintf(":%s", port),
+		Handler:           router,
+		ReadHeaderTimeout: time.Minute,
+	}
+
+	go func() {
+		if runServerErr := srv.ListenAndServe(); runServerErr != nil && !errors.Is(runServerErr, http.ErrServerClosed) {
+			log.Crit("run coordinator http server failure", "error", runServerErr)
+		}
+	}()
+	return srv
+}
+
 // Run coordinator.
 func Run() {
 	// RunApp the coordinator.

coordinator/go.mod

@@ -71,4 +71,4 @@ require (
 	golang.org/x/crypto v0.12.0 // indirect
 	golang.org/x/sys v0.11.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
+)

coordinator/internal/route/route.go

@@ -4,7 +4,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/client_golang/prometheus"
 
-	"scroll-tech/common/ginmetrics"
+	"scroll-tech/common/metrics"
 
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/controller/api"
@@ -15,22 +15,13 @@ import (
 func Route(router *gin.Engine, cfg *config.Config, reg prometheus.Registerer) {
 	router.Use(gin.Recovery())
 
-	apiMetric(router, reg)
+	metrics.Use(router, "coordinator", reg)
 
 	r := router.Group("coordinator")
 
 	v1(r, cfg)
 }
 
-func apiMetric(r *gin.Engine, reg prometheus.Registerer) {
-	m := ginmetrics.GetMonitor(reg)
-	m.SetMetricPath("/metrics")
-	m.SetMetricPrefix("coordinator_")
-	m.SetSlowTime(1)
-	m.SetDuration([]float64{0.025, .05, .1, .5, 1, 5, 10})
-	m.Use(r)
-}
-
 func v1(router *gin.RouterGroup, conf *config.Config) {
 	r := router.Group("/v1")