Merge pull request #313 from go-kit/new-metrics

Refactor package metrics

.travis.yml

@@ -4,5 +4,6 @@ script: go test -race -v ./...
 
 go:
     - 1.5.3
-    - 1.6
-    #- tip
+    - 1.6.3
+    - 1.7
+    - tip

examples/addsvc/cmd/addsvc/main.go

@@ -10,7 +10,6 @@ import (
 	"os/signal"
 	"strings"
 	"syscall"
-	"time"
 
 	"github.com/apache/thrift/lib/go/thrift"
 	lightstep "github.com/lightstep/lightstep-tracer-go"
@@ -61,25 +60,25 @@ func main() {
 	var ints, chars metrics.Counter
 	{
 		// Business level metrics.
-		ints = prometheus.NewCounter(stdprometheus.CounterOpts{
+		ints = prometheus.NewCounterFrom(stdprometheus.CounterOpts{
 			Namespace: "addsvc",
 			Name:      "integers_summed",
 			Help:      "Total count of integers summed via the Sum method.",
 		}, []string{})
-		chars = prometheus.NewCounter(stdprometheus.CounterOpts{
+		chars = prometheus.NewCounterFrom(stdprometheus.CounterOpts{
 			Namespace: "addsvc",
 			Name:      "characters_concatenated",
 			Help:      "Total count of characters concatenated via the Concat method.",
 		}, []string{})
 	}
-	var duration metrics.TimeHistogram
+	var duration metrics.Histogram
 	{
 		// Transport level metrics.
-		duration = metrics.NewTimeHistogram(time.Nanosecond, prometheus.NewSummary(stdprometheus.SummaryOpts{
+		duration = prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
 			Namespace: "addsvc",
 			Name:      "request_duration_ns",
 			Help:      "Request duration in nanoseconds.",
-		}, []string{"method", "success"}))
+		}, []string{"method", "success"})
 	}
 
 	// Tracing domain.
@@ -132,7 +131,7 @@ func main() {
 	// Endpoint domain.
 	var sumEndpoint endpoint.Endpoint
 	{
-		sumDuration := duration.With(metrics.Field{Key: "method", Value: "Sum"})
+		sumDuration := duration.With("method", "Sum")
 		sumLogger := log.NewContext(logger).With("method", "Sum")
 
 		sumEndpoint = addsvc.MakeSumEndpoint(service)
@@ -142,7 +141,7 @@ func main() {
 	}
 	var concatEndpoint endpoint.Endpoint
 	{
-		concatDuration := duration.With(metrics.Field{Key: "method", Value: "Concat"})
+		concatDuration := duration.With("method", "Concat")
 		concatLogger := log.NewContext(logger).With("method", "Concat")
 
 		concatEndpoint = addsvc.MakeConcatEndpoint(service)

examples/addsvc/endpoints.go

@@ -88,13 +88,12 @@ func MakeConcatEndpoint(s Service) endpoint.Endpoint {
 // the duration of each invocation to the passed histogram. The middleware adds
 // a single field: "success", which is "true" if no error is returned, and
 // "false" otherwise.
-func EndpointInstrumentingMiddleware(duration metrics.TimeHistogram) endpoint.Middleware {
+func EndpointInstrumentingMiddleware(duration metrics.Histogram) endpoint.Middleware {
 	return func(next endpoint.Endpoint) endpoint.Endpoint {
 		return func(ctx context.Context, request interface{}) (response interface{}, err error) {
 
 			defer func(begin time.Time) {
-				f := metrics.Field{Key: "success", Value: fmt.Sprint(err == nil)}
-				duration.With(f).Observe(time.Since(begin))
+				duration.With("success", fmt.Sprint(err == nil)).Observe(time.Since(begin).Seconds())
 			}(time.Now())
 			return next(ctx, request)
 

examples/addsvc/service.go

@@ -153,12 +153,12 @@ type serviceInstrumentingMiddleware struct {
 
 func (mw serviceInstrumentingMiddleware) Sum(ctx context.Context, a, b int) (int, error) {
 	v, err := mw.next.Sum(ctx, a, b)
-	mw.ints.Add(uint64(v))
+	mw.ints.Add(float64(v))
 	return v, err
 }
 
 func (mw serviceInstrumentingMiddleware) Concat(ctx context.Context, a, b string) (string, error) {
 	v, err := mw.next.Concat(ctx, a, b)
-	mw.chars.Add(uint64(len(v)))
+	mw.chars.Add(float64(len(v)))
 	return v, err
 }

examples/shipping/booking/instrumenting.go

@@ -11,12 +11,12 @@ import (
 
 type instrumentingService struct {
 	requestCount   metrics.Counter
-	requestLatency metrics.TimeHistogram
+	requestLatency metrics.Histogram
 	Service
 }
 
 // NewInstrumentingService returns an instance of an instrumenting Service.
-func NewInstrumentingService(requestCount metrics.Counter, requestLatency metrics.TimeHistogram, s Service) Service {
+func NewInstrumentingService(requestCount metrics.Counter, requestLatency metrics.Histogram, s Service) Service {
 	return &instrumentingService{
 		requestCount:   requestCount,
 		requestLatency: requestLatency,
@@ -26,69 +26,62 @@ func NewInstrumentingService(requestCount metrics.Counter, requestLatency metric
 
 func (s *instrumentingService) BookNewCargo(origin, destination location.UNLocode, arrivalDeadline time.Time) (cargo.TrackingID, error) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "book"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "book").Add(1)
+		s.requestLatency.With("method", "book").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.BookNewCargo(origin, destination, arrivalDeadline)
 }
 
 func (s *instrumentingService) LoadCargo(id cargo.TrackingID) (c Cargo, err error) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "load"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "load").Add(1)
+		s.requestLatency.With("method", "load").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.LoadCargo(id)
 }
 
 func (s *instrumentingService) RequestPossibleRoutesForCargo(id cargo.TrackingID) []cargo.Itinerary {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "request_routes"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "request_routes").Add(1)
+		s.requestLatency.With("method", "request_routes").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.RequestPossibleRoutesForCargo(id)
 }
 
 func (s *instrumentingService) AssignCargoToRoute(id cargo.TrackingID, itinerary cargo.Itinerary) (err error) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "assign_to_route"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "assign_to_route").Add(1)
+		s.requestLatency.With("method", "assign_to_route").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.AssignCargoToRoute(id, itinerary)
 }
 
 func (s *instrumentingService) ChangeDestination(id cargo.TrackingID, l location.UNLocode) (err error) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "change_destination"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "change_destination").Add(1)
+		s.requestLatency.With("method", "change_destination").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.ChangeDestination(id, l)
 }
 
 func (s *instrumentingService) Cargos() []Cargo {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "list_cargos"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "list_cargos").Add(1)
+		s.requestLatency.With("method", "list_cargos").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.Cargos()
 }
 
 func (s *instrumentingService) Locations() []Location {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "list_locations"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "list_locations").Add(1)
+		s.requestLatency.With("method", "list_locations").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.Locations()

examples/shipping/handling/instrumenting.go

@@ -12,12 +12,12 @@ import (
 
 type instrumentingService struct {
 	requestCount   metrics.Counter
-	requestLatency metrics.TimeHistogram
+	requestLatency metrics.Histogram
 	Service
 }
 
 // NewInstrumentingService returns an instance of an instrumenting Service.
-func NewInstrumentingService(requestCount metrics.Counter, requestLatency metrics.TimeHistogram, s Service) Service {
+func NewInstrumentingService(requestCount metrics.Counter, requestLatency metrics.Histogram, s Service) Service {
 	return &instrumentingService{
 		requestCount:   requestCount,
 		requestLatency: requestLatency,
@@ -29,9 +29,8 @@ func (s *instrumentingService) RegisterHandlingEvent(completionTime time.Time, t
 	loc location.UNLocode, eventType cargo.HandlingEventType) error {
 
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "register_incident"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "register_incident").Add(1)
+		s.requestLatency.With("method", "register_incident").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.RegisterHandlingEvent(completionTime, trackingID, voyage, loc, eventType)

examples/shipping/main.go

@@ -14,7 +14,6 @@ import (
 	"golang.org/x/net/context"
 
 	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/metrics"
 	kitprometheus "github.com/go-kit/kit/metrics/prometheus"
 
 	"github.com/go-kit/kit/examples/shipping/booking"
@@ -81,52 +80,58 @@ func main() {
 	bs = booking.NewService(cargos, locations, handlingEvents, rs)
 	bs = booking.NewLoggingService(log.NewContext(logger).With("component", "booking"), bs)
 	bs = booking.NewInstrumentingService(
-		kitprometheus.NewCounter(stdprometheus.CounterOpts{
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
 			Namespace: "api",
 			Subsystem: "booking_service",
 			Name:      "request_count",
 			Help:      "Number of requests received.",
 		}, fieldKeys),
-		metrics.NewTimeHistogram(time.Microsecond, kitprometheus.NewSummary(stdprometheus.SummaryOpts{
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
 			Namespace: "api",
 			Subsystem: "booking_service",
 			Name:      "request_latency_microseconds",
 			Help:      "Total duration of requests in microseconds.",
-		}, fieldKeys)), bs)
+		}, fieldKeys),
+		bs,
+	)
 
 	var ts tracking.Service
 	ts = tracking.NewService(cargos, handlingEvents)
 	ts = tracking.NewLoggingService(log.NewContext(logger).With("component", "tracking"), ts)
 	ts = tracking.NewInstrumentingService(
-		kitprometheus.NewCounter(stdprometheus.CounterOpts{
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
 			Namespace: "api",
 			Subsystem: "tracking_service",
 			Name:      "request_count",
 			Help:      "Number of requests received.",
 		}, fieldKeys),
-		metrics.NewTimeHistogram(time.Microsecond, kitprometheus.NewSummary(stdprometheus.SummaryOpts{
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
 			Namespace: "api",
 			Subsystem: "tracking_service",
 			Name:      "request_latency_microseconds",
 			Help:      "Total duration of requests in microseconds.",
-		}, fieldKeys)), ts)
+		}, fieldKeys),
+		ts,
+	)
 
 	var hs handling.Service
 	hs = handling.NewService(handlingEvents, handlingEventFactory, handlingEventHandler)
 	hs = handling.NewLoggingService(log.NewContext(logger).With("component", "handling"), hs)
 	hs = handling.NewInstrumentingService(
-		kitprometheus.NewCounter(stdprometheus.CounterOpts{
+		kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
 			Namespace: "api",
 			Subsystem: "handling_service",
 			Name:      "request_count",
 			Help:      "Number of requests received.",
 		}, fieldKeys),
-		metrics.NewTimeHistogram(time.Microsecond, kitprometheus.NewSummary(stdprometheus.SummaryOpts{
+		kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
 			Namespace: "api",
 			Subsystem: "handling_service",
 			Name:      "request_latency_microseconds",
 			Help:      "Total duration of requests in microseconds.",
-		}, fieldKeys)), hs)
+		}, fieldKeys),
+		hs,
+	)
 
 	httpLogger := log.NewContext(logger).With("component", "http")
 

examples/shipping/tracking/instrumenting.go

@@ -8,12 +8,12 @@ import (
 
 type instrumentingService struct {
 	requestCount   metrics.Counter
-	requestLatency metrics.TimeHistogram
+	requestLatency metrics.Histogram
 	Service
 }
 
 // NewInstrumentingService returns an instance of an instrumenting Service.
-func NewInstrumentingService(requestCount metrics.Counter, requestLatency metrics.TimeHistogram, s Service) Service {
+func NewInstrumentingService(requestCount metrics.Counter, requestLatency metrics.Histogram, s Service) Service {
 	return &instrumentingService{
 		requestCount:   requestCount,
 		requestLatency: requestLatency,
@@ -23,9 +23,8 @@ func NewInstrumentingService(requestCount metrics.Counter, requestLatency metric
 
 func (s *instrumentingService) Track(id string) (Cargo, error) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "track"}
-		s.requestCount.With(methodField).Add(1)
-		s.requestLatency.With(methodField).Observe(time.Since(begin))
+		s.requestCount.With("method", "track").Add(1)
+		s.requestLatency.With("method", "track").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	return s.Service.Track(id)

examples/stringsvc2/instrumenting.go

@@ -9,17 +9,16 @@ import (
 
 type instrumentingMiddleware struct {
 	requestCount   metrics.Counter
-	requestLatency metrics.TimeHistogram
+	requestLatency metrics.Histogram
 	countResult    metrics.Histogram
 	next           StringService
 }
 
 func (mw instrumentingMiddleware) Uppercase(s string) (output string, err error) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "uppercase"}
-		errorField := metrics.Field{Key: "error", Value: fmt.Sprintf("%v", err)}
-		mw.requestCount.With(methodField).With(errorField).Add(1)
-		mw.requestLatency.With(methodField).With(errorField).Observe(time.Since(begin))
+		lvs := []string{"method", "uppercase", "error", fmt.Sprint(err == nil)}
+		mw.requestCount.With(lvs...).Add(1)
+		mw.requestLatency.With(lvs...).Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
 	output, err = mw.next.Uppercase(s)
@@ -28,11 +27,10 @@ func (mw instrumentingMiddleware) Uppercase(s string) (output string, err error)
 
 func (mw instrumentingMiddleware) Count(s string) (n int) {
 	defer func(begin time.Time) {
-		methodField := metrics.Field{Key: "method", Value: "count"}
-		errorField := metrics.Field{Key: "error", Value: fmt.Sprintf("%v", error(nil))}
-		mw.requestCount.With(methodField).With(errorField).Add(1)
-		mw.requestLatency.With(methodField).With(errorField).Observe(time.Since(begin))
-		mw.countResult.Observe(int64(n))
+		lvs := []string{"method", "count"}
+		mw.requestCount.With(lvs...).Add(1)
+		mw.requestLatency.With(lvs...).Observe(time.Since(begin).Seconds())
+		mw.countResult.Observe(float64(n))
 	}(time.Now())
 
 	n = mw.next.Count(s)