Metrics

Metrics middleware is used to monitor performance metrics for services, counting request time and request counts.

Configuration

Two configuration methods are available in metrics middleware WithSeconds() and WithRequests()。

WithSeconds()

  1. func WithSeconds(c metrics.Observer) Option {
  2.     return func(o *options) {
  3.         o.seconds = c
  4.     }
  5. }

The Observer histogram used to set up the metrics middleware statistics request.

WithRequests()

  1. func WithRequests(c metrics.Counter) Option {
  2.     return func(o *options) {
  3.         o.requests = c
  4.     }
  5. }

The Counter counter used to set the metrics middleware statistics request count.

Usage (kratos < 2.8.0)

Prometheus

  1. // Detailed reference https://github.com/go-kratos/examples/tree/main/metrics
  3. _metricSeconds = prometheus.NewHistogramVec(prometheus.HistogramOpts{
  4.     Namespace: "server",
  5.     Subsystem: "requests",
  6.     Name:      "duration_sec",
  7.     Help:      "server requests duratio(sec).",
  8.     Buckets:   []float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.250, 0.5, 1},
  9. }, []string{"kind", "operation"})
  11. _metricRequests = prometheus.NewCounterVec(prometheus.CounterOpts{
  12.     Namespace: "client",
  13.     Subsystem: "requests",
  14.     Name:      "code_total",
  15.     Help:      "The total number of processed requests",
  16. }, []string{"kind", "operation", "code", "reason"})
  18. prometheus.MustRegister(_metricSeconds, _metricRequests)

To configure metrics in servers

  1. import (
  2.     prom "github.com/go-kratos/kratos/contrib/metrics/prometheus/v2"
  3. )
  5. // grpc service
  6. grpcSrv := grpc.NewServer(
  7.     grpc.Address(":9000"),
  8.     grpc.Middleware(
  9.         metrics.Server(
  10.             metrics.WithSeconds(prom.NewHistogram(_metricSeconds)),
  11.             metrics.WithRequests(prom.NewCounter(_metricRequests)),
  12.         ),
  13.     ),
  14. )
  16. // http service
  17. httpSrv := http.NewServer(
  18.     http.Address(":8000"),
  19.     http.Middleware(
  20.         metrics.Server(
  21.             metrics.WithSeconds(prom.NewHistogram(_metricSeconds)),
  22.             metrics.WithRequests(prom.NewCounter(_metricRequests)),
  23.         ),
  24.     ),
  25. )
  26. httpSrv.Handle("/metrics", promhttp.Handler())

To configure metrics in clients

  1. // grpc client
  2. conn, err := grpc.DialInsecure(
  3.     context.Background(),
  4.     grpc.WithEndpoint("127.0.0.1:9000"),
  5.     grpc.WithMiddleware(
  6.         metrics.Client(
  7.             metrics.WithSeconds(prom.NewHistogram(_metricSeconds)),
  8.             metrics.WithRequests(prom.NewCounter(_metricRequests)),
  9.         ),
  10.     ),
  11. )
  13. // http client
  14. conn, err := http.NewClient(
  15.     context.Background(),
  16.     http.WithEndpoint("127.0.0.1:8000"),
  17.     http.WithMiddleware(
  18.         metrics.Client(
  19.             metrics.WithSeconds(prom.NewHistogram(_metricSeconds)),
  20.             metrics.WithRequests(prom.NewCounter(_metricRequests)),
  21.         ),
  22.     ),
  23. )

Usage (kratos >= 2.8.0)

Since version v2.8.0, kratos uses otel.Metrics. Way to export metrics to prometheus is as follows:

Prometheus

  1. import (
  2.     "github.com/go-kratos/kratos/v2/middleware/metrics"
  3.     "go.opentelemetry.io/otel/exporters/prometheus"
  4.     "go.opentelemetry.io/otel/metric"
  5.     sdkmetric "go.opentelemetry.io/otel/sdk/metric"
  6. )
  8. // Detailed reference https://github.com/go-kratos/examples/tree/main/metrics
  9. func init() {
  10.     exporter, err := prometheus.New()
  11.     if err != nil {
  12.         panic(err)
  13.     }
  14.     provider := sdkmetric.NewMeterProvider(sdkmetric.WithReader(exporter))
  15.     meter := provider.Meter(Name)
  17.     _metricRequests, err = metrics.DefaultRequestsCounter(meter, metrics.DefaultServerRequestsCounterName)
  18.     if err != nil {
  19.         panic(err)
  20.     }
  22.     _metricSeconds, err = metrics.DefaultSecondsHistogram(meter, metrics.DefaultServerSecondsHistogramName)
  23.     if err != nil {
  24.         panic(err)
  25.     }
  26. }

To configure metrics in servers

  1. import (
  2.     "github.com/prometheus/client_golang/prometheus/promhttp"
  3. )
  5. // grpc service
  6. grpcSrv := grpc.NewServer(
  7.     grpc.Address(":9000"),
  8.     grpc.Middleware(
  9.         metrics.Server(
  10.             metrics.WithSeconds(_metricSeconds),
  11.             metrics.WithRequests(_metricRequests),
  12.         ),
  13.     ),
  14. )
  16. // http service
  17. httpSrv := http.NewServer(
  18.     http.Address(":8000"),
  19.     http.Middleware(
  20.         metrics.Server(
  21.             metrics.WithSeconds(_metricSeconds),
  22.             metrics.WithRequests(_metricRequests),
  23.         ),
  24.     ),
  25. )
  26. httpSrv.Handle("/metrics", promhttp.Handler())

To configure metrics in clients

  1. // grpc client
  2. conn, err := grpc.DialInsecure(
  3.     context.Background(),
  4.     grpc.WithEndpoint("127.0.0.1:9000"),
  5.     grpc.WithMiddleware(
  6.         metrics.Client(
  7.             metrics.WithSeconds(_metricSeconds),
  8.             metrics.WithRequests(_metricRequests),
  9.         ),
  10.     ),
  11. )
  13. // http client
  14. conn, err := http.NewClient(
  15.     context.Background(),
  16.     http.WithEndpoint("127.0.0.1:8000"),
  17.     http.WithMiddleware(
  18.         metrics.Client(
  19.             metrics.WithSeconds(_metricSeconds),
  20.             metrics.WithRequests(_metricRequests),
  21.         ),
  22.     ),
  23. )

References