1 files changed, 159 insertions, 0 deletions

diff --git a/echo/prometheus/prometheus.go b/echo/prometheus/prometheus.go
new file mode 100644
index 0000000..616e425
--- /dev/null
+++ b/echo/prometheus/prometheus.go
@@ -0,0 +1,159 @@
+package prometheus
+
+import (
+        "errors"
+        "net/http"
+        "strconv"
+        "time"
+
+        "github.com/labstack/echo/v4"
+        "github.com/labstack/echo/v4/middleware"
+        "github.com/prometheus/client_golang/prometheus"
+        "github.com/prometheus/client_golang/prometheus/promauto"
+        "github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+type Prometheus struct {
+        config          *PrometheusConfig
+        requestCount    *prometheus.CounterVec
+        requestDuration *prometheus.HistogramVec
+        requestSize     *prometheus.HistogramVec
+        responseSize    *prometheus.HistogramVec
+        MetricsHandler  echo.HandlerFunc
+}
+
+type PrometheusConfig struct {
+        Skipper      middleware.Skipper
+        ExtractUrl   func(c echo.Context) string
+        ExtractHost  func(c echo.Context) string
+        ContextLabel string // Context var name to use as a prometheus URL label
+        MetricsPath  string
+        Subsystem    string
+}
+
+var DefaultPrometheusConfig = &PrometheusConfig{
+        Skipper: middleware.DefaultSkipper,
+        ExtractUrl: func(c echo.Context) string {
+                return c.Path()
+        },
+        ExtractHost: func(c echo.Context) string {
+                return c.Request().Host
+        },
+        MetricsPath: "/metrics",
+        Subsystem:   "echo",
+}
+
+func NewPrometheus() *Prometheus {
+        return NewPrometheusWithConfig(DefaultPrometheusConfig)
+}
+
+func NewPrometheusWithConfig(c *PrometheusConfig) *Prometheus {
+        if c.Subsystem == "" {
+                c.Subsystem = DefaultPrometheusConfig.Subsystem
+        }
+        if c.MetricsPath == "" {
+                c.MetricsPath = DefaultPrometheusConfig.MetricsPath
+        }
+        if c.Skipper == nil {
+                c.Skipper = middleware.DefaultSkipper
+        }
+        if c.ExtractUrl == nil {
+                c.ExtractUrl = DefaultPrometheusConfig.ExtractUrl
+        }
+        if c.ExtractHost == nil {
+                c.ExtractHost = DefaultPrometheusConfig.ExtractHost
+        }
+
+        return &Prometheus{
+                config:         c,
+                MetricsHandler: echo.WrapHandler(promhttp.Handler()),
+                requestCount: promauto.NewCounterVec(prometheus.CounterOpts{
+                        Subsystem: c.Subsystem,
+                        Name:      "requests_total",
+                        Help:      "How many HTTP requests processed, partitioned by status code and HTTP method.",
+                }, []string{"code", "method", "host", "url"}),
+                requestDuration: promauto.NewHistogramVec(prometheus.HistogramOpts{
+                        Subsystem: c.Subsystem,
+                        Name:      "request_duration_seconds",
+                        Help:      "The HTTP request latencies in seconds.",
+                }, []string{"code", "method", "url"}),
+                requestSize: promauto.NewHistogramVec(prometheus.HistogramOpts{
+                        Subsystem: c.Subsystem,
+                        Name:      "response_size_bytes",
+                        Help:      "The HTTP response sizes in bytes.",
+                }, []string{"code", "method", "url"}),
+                responseSize: promauto.NewHistogramVec(prometheus.HistogramOpts{
+                        Subsystem: c.Subsystem,
+                        Name:      "request_size_bytes",
+                        Help:      "The HTTP request sizes in bytes.",
+                }, []string{"code", "method", "url"}),
+        }
+}
+
+func (p *Prometheus) MiddlewareHandler(next echo.HandlerFunc) echo.HandlerFunc {
+        return func(c echo.Context) error {
+                if c.Path() == p.config.MetricsPath {
+                        return next(c)
+                }
+
+                if p.config.Skipper(c) {
+                        return next(c)
+                }
+
+                start := time.Now()
+                reqSz := computeApproximateRequestSize(c.Request())
+                err := next(c)
+                elapsed := float64(time.Since(start)) / float64(time.Second)
+
+                status := c.Response().Status
+                if err != nil {
+                        var httpError *echo.HTTPError
+                        if errors.As(err, &httpError) {
+                                status = httpError.Code
+                        }
+                        if status == 0 || status == http.StatusOK {
+                                status = http.StatusInternalServerError
+                        }
+                }
+
+                url := p.config.ExtractUrl(c)
+                if len(p.config.ContextLabel) > 0 {
+                        u := c.Get(p.config.ContextLabel)
+                        if u == nil {
+                                u = "unknown"
+                        }
+                        url = u.(string)
+                }
+
+                s := strconv.Itoa(status)
+                m := c.Request().Method
+                p.requestDuration.WithLabelValues(s, m, url).Observe(elapsed)
+                p.requestCount.WithLabelValues(s, m, p.config.ExtractHost(c), url).Inc()
+                p.requestSize.WithLabelValues(s, m, url).Observe(float64(reqSz))
+                p.responseSize.WithLabelValues(s, m, url).Observe(float64(c.Response().Size))
+
+                return err
+        }
+}
+
+func computeApproximateRequestSize(r *http.Request) int {
+        s := 0
+        if r.URL != nil {
+                s = len(r.URL.Path)
+        }
+
+        s += len(r.Method)
+        s += len(r.Proto)
+        for name, values := range r.Header {
+                s += len(name)
+                for _, value := range values {
+                        s += len(value)
+                }
+        }
+        s += len(r.Host)
+
+        if r.ContentLength != -1 {
+                s += int(r.ContentLength)
+        }
+        return s
+}