package middlewares import ( "net/http" "strconv" "time" "github.com/go-kit/kit/metrics" "github.com/go-kit/kit/metrics/multi" ) // Metrics is an Interface that must be satisfied by any system that // wants to expose and monitor Metrics. type Metrics interface { getReqsCounter() metrics.Counter getReqDurationHistogram() metrics.Histogram RetryMetrics } // RetryMetrics must be satisfied by any system that wants to collect and // expose retry specific Metrics. type RetryMetrics interface { getRetryCounter() metrics.Counter } // MultiMetrics is a struct that provides a wrapper container for multiple Metrics, if they are configured type MultiMetrics struct { wrappedMetrics *[]Metrics reqsCounter metrics.Counter reqDurationHistogram metrics.Histogram retryCounter metrics.Counter } // NewMultiMetrics creates a new instance of MultiMetrics func NewMultiMetrics(manyMetrics []Metrics) *MultiMetrics { counters := []metrics.Counter{} histograms := []metrics.Histogram{} retryCounters := []metrics.Counter{} for _, m := range manyMetrics { counters = append(counters, m.getReqsCounter()) histograms = append(histograms, m.getReqDurationHistogram()) retryCounters = append(retryCounters, m.getRetryCounter()) } var mm MultiMetrics mm.wrappedMetrics = &manyMetrics mm.reqsCounter = multi.NewCounter(counters...) mm.reqDurationHistogram = multi.NewHistogram(histograms...) mm.retryCounter = multi.NewCounter(retryCounters...) return &mm } func (mm *MultiMetrics) getReqsCounter() metrics.Counter { return mm.reqsCounter } func (mm *MultiMetrics) getReqDurationHistogram() metrics.Histogram { return mm.reqDurationHistogram } func (mm *MultiMetrics) getRetryCounter() metrics.Counter { return mm.retryCounter } func (mm *MultiMetrics) getWrappedMetrics() *[]Metrics { return mm.wrappedMetrics } // MetricsWrapper is a Negroni compatible Handler which relies on a // given Metrics implementation to expose and monitor Traefik Metrics. type MetricsWrapper struct { Impl Metrics } // NewMetricsWrapper return a MetricsWrapper struct with // a given Metrics implementation e.g Prometheuss func NewMetricsWrapper(impl Metrics) *MetricsWrapper { var metricsWrapper = MetricsWrapper{ Impl: impl, } return &metricsWrapper } func (m *MetricsWrapper) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) { start := time.Now() prw := &responseRecorder{rw, http.StatusOK} next(prw, r) reqLabels := []string{"code", strconv.Itoa(prw.statusCode), "method", r.Method} m.Impl.getReqsCounter().With(reqLabels...).Add(1) reqDurationLabels := []string{"code", strconv.Itoa(prw.statusCode)} m.Impl.getReqDurationHistogram().With(reqDurationLabels...).Observe(float64(time.Since(start).Seconds())) } // MetricsRetryListener is an implementation of the RetryListener interface to // record Metrics about retry attempts. type MetricsRetryListener struct { retryMetrics RetryMetrics } // Retried tracks the retry in the Metrics implementation. func (m *MetricsRetryListener) Retried(attempt int) { if m.retryMetrics != nil { m.retryMetrics.getRetryCounter().Add(1) } } // NewMetricsRetryListener instantiates a MetricsRetryListener with the given RetryMetrics. func NewMetricsRetryListener(retryMetrics RetryMetrics) RetryListener { return &MetricsRetryListener{retryMetrics: retryMetrics} }