All Projects → slok → Go Http Metrics

slok / Go Http Metrics

Licence: apache-2.0
Go modular http middleware to measure HTTP requests independent of metrics backend (with Prometheus and OpenCensus as backend implementations) and http framework/library

Programming Languages

go
31211 projects - #10 most used programming language
golang
3204 projects

Projects that are alternatives of or similar to Go Http Metrics

Mtail
extract internal monitoring data from application logs for collection in a timeseries database
Stars: ✭ 3,028 (+2265.63%)
Mutual labels:  metrics, prometheus, observability, instrumentation
druid-prometheus-exporter
Service to collect Apache Druid metrics and export them to Prometheus
Stars: ✭ 14 (-89.06%)
Mutual labels:  metrics, prometheus, gin
gateway
A proxy to buffer and forward metrics, events, and traces.
Stars: ✭ 94 (-26.56%)
Mutual labels:  metrics, prometheus, observability
Prometheus.erl
Prometheus.io client in Erlang
Stars: ✭ 276 (+115.63%)
Mutual labels:  metrics, prometheus, instrumentation
Prometheus rabbitmq exporter
Prometheus.io exporter as a RabbitMQ Managment Plugin plugin
Stars: ✭ 248 (+93.75%)
Mutual labels:  metrics, prometheus, instrumentation
ginprom
Gin Prometheus metrics exporter inspired by https://github.com/zsais/go-gin-prometheus
Stars: ✭ 97 (-24.22%)
Mutual labels:  prometheus, instrumentation, gin
Client java
Prometheus instrumentation library for JVM applications
Stars: ✭ 1,644 (+1184.38%)
Mutual labels:  metrics, prometheus, instrumentation
Client python
Prometheus instrumentation library for Python applications
Stars: ✭ 2,500 (+1853.13%)
Mutual labels:  metrics, prometheus, instrumentation
Prometheus.ex
Prometheus.io Elixir client
Stars: ✭ 343 (+167.97%)
Mutual labels:  metrics, prometheus, instrumentation
Swagger Stats
API Observability. Trace API calls and Monitor API performance, health and usage statistics in Node.js Microservices.
Stars: ✭ 559 (+336.72%)
Mutual labels:  metrics, prometheus, observability
Grafterm
Metrics dashboards on terminal (a grafana inspired terminal version)
Stars: ✭ 613 (+378.91%)
Mutual labels:  metrics, prometheus, observability
Datav
📊https://datav.io is a modern APM, provide observability for your business, application and infrastructure. It's also a lightweight alternative to Grafana.
Stars: ✭ 2,757 (+2053.91%)
Mutual labels:  metrics, observability, prometheus
Prometheus.cl
Prometheus.io Common Lisp client
Stars: ✭ 67 (-47.66%)
Mutual labels:  metrics, prometheus, instrumentation
prometheus-httpd
Expose Prometheus metrics using inets httpd.
Stars: ✭ 21 (-83.59%)
Mutual labels:  metrics, prometheus, instrumentation
Graphite exporter
Server that accepts metrics via the Graphite protocol and exports them as Prometheus metrics
Stars: ✭ 217 (+69.53%)
Mutual labels:  metrics, prometheus, observability
Kube State Metrics
Add-on agent to generate and expose cluster-level metrics.
Stars: ✭ 3,433 (+2582.03%)
Mutual labels:  metrics, prometheus, observability
Appmetrics
App Metrics is an open-source and cross-platform .NET library used to record and report metrics within an application.
Stars: ✭ 1,986 (+1451.56%)
Mutual labels:  metrics, prometheus, instrumentation
Influxdb exporter
A server that accepts InfluxDB metrics via the HTTP API and exports them via HTTP for Prometheus consumption
Stars: ✭ 159 (+24.22%)
Mutual labels:  metrics, prometheus, observability
Skywalking
APM, Application Performance Monitoring System
Stars: ✭ 18,341 (+14228.91%)
Mutual labels:  metrics, prometheus, observability
Gin Stats
Gin's middleware for request stats
Stars: ✭ 24 (-81.25%)
Mutual labels:  middleware, gin, metrics

go-http-metrics Build Status Go Report Card GoDoc

go-http-metrics knows how to measure http metrics in different metric formats and Go HTTP framework/libs. The metrics measured are based on RED and/or Four golden signals, follow standards and try to be measured in a efficient way.

Table of contents

Metrics

The metrics obtained with this middleware are the most important ones for a HTTP service.

  • Records the duration of the requests(with: code, handler, method).
  • Records the count of the requests(with: code, handler, method).
  • Records the size of the responses(with: code, handler, method).
  • Records the number requests being handled concurrently at a given time a.k.a inflight requests (with: handler).

Metrics recorder implementations

go-http-metrics is easy to extend to different metric backends by implementing metrics.Recorder interface.

Framework compatibility middlewares

The middleware is mainly focused to be compatible with Go std library using http.Handler, but it comes with helpers to get middlewares for other frameworks or libraries.

It supports any framework that supports http.Handler provider type middleware func(http.Handler) http.Handler (e.g Chi, Alice, Gorilla...). Use std.HandlerProvider

Getting Started

A simple example that uses Prometheus as the recorder with the standard Go handler.

package main

import (
    "log"
    "net/http"

    "github.com/prometheus/client_golang/prometheus/promhttp"
    metrics "github.com/slok/go-http-metrics/metrics/prometheus"
    "github.com/slok/go-http-metrics/middleware"
    middlewarestd "github.com/slok/go-http-metrics/middleware/std"
)

func main() {
    // Create our middleware.
    mdlw := middleware.New(middleware.Config{
        Recorder: metrics.NewRecorder(metrics.Config{}),
    })

    // Our handler.
    h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("hello world!"))
    })
    h = middlewarestd.Handler("", mdlw, h)

    // Serve metrics.
    log.Printf("serving metrics at: %s", ":9090")
    go http.ListenAndServe(":9090", promhttp.Handler())

    // Serve our handler.
    log.Printf("listening at: %s", ":8080")
    if err := http.ListenAndServe(":8080", h); err != nil {
        log.Panicf("error while serving: %s", err)
    }
}

For more examples check the examples. default and custom are the examples for Go net/http std library users.

Prometheus query examples

Get the request rate by handler:

sum(
    rate(http_request_duration_seconds_count[30s])
) by (handler)

Get the request error rate:

rate(http_request_duration_seconds_count{code=~"5.."}[30s])

Get percentile 99 of the whole service:

histogram_quantile(0.99,
    rate(http_request_duration_seconds_bucket[5m]))

Get percentile 90 of each handler:

histogram_quantile(0.9,
    sum(
        rate(http_request_duration_seconds_bucket[10m])
    ) by (handler, le)
)

Options

Middleware Options

The factory options are the ones that are passed in the moment of creating the middleware factory using the middleware.Config object.

Recorder

This is the implementation of the metrics backend, by default it's a dummy recorder.

Service

This is an optional argument that can be used to set a specific service on all the middleware metrics, this is helpful when the service uses multiple middlewares on the same app, for example for the HTTP api server and the metrics server. This also gives the ability to use the same recorder with different middlewares.

GroupedStatus

Storing all the status codes could increase the cardinality of the metrics, usually this is not a common case because the used status codes by a service are not too much and are finite, but some services use a lot of different status codes, grouping the status on the \dxx form could impact the performance (in a good way) of the queries on Prometheus (as they are already aggregated), on the other hand it losses detail. For example the metrics code code="401", code="404", code="403" with this enabled option would end being code="4xx" label. By default is disabled.

DisableMeasureSize

This setting will disable measuring the size of the responses. By default measuring the size is enabled.

DisableMeasureInflight

This settings will disable measuring the number of requests being handled concurrently by the handlers.

Custom handler ID

One of the options that you need to pass when wrapping the handler with the middleware is handlerID, this has 2 working ways.

  • If an empty string is passed mdwr.Handler("", h) it will get the handler label from the url path. This will create very high cardnialty on the metrics because /p/123/dashboard/1, /p/123/dashboard/2 and /p/9821/dashboard/1 would have different handler labels. This method is only recomended when the URLs are fixed (not dynamic or don't have parameters on the path).

  • If a predefined handler ID is passed, mdwr.Handler("/p/:userID/dashboard/:page", h) this will keep cardinality low because /p/123/dashboard/1, /p/123/dashboard/2 and /p/9821/dashboard/1 would have the same handler label on the metrics.

There are different parameters to set up your middleware factory, you can check everything on the docs and see the usage in the examples.

Prometheus recorder options

Prefix

This option will make exposed metrics have a {PREFIX}_ in fornt of the metric. For example if a regular exposed metric is http_request_duration_seconds_count and I use Prefix: batman my exposed metric will be batman_http_request_duration_seconds_count. By default this will be disabled or empty, but can be useful if all the metrics of the app are prefixed with the app name.

DurationBuckets

DurationBuckets are the buckets used for the request duration histogram metric, by default it will use Prometheus defaults, this is from 5ms to 10s, on a regular HTTP service this is very common and in most cases this default works perfect, but on some cases where the latency is very low or very high due the nature of the service, this could be changed to measure a different range of time. Example, from 500ms to 320s Buckets: []float64{.5, 1, 2.5, 5, 10, 20, 40, 80, 160, 320}. Is not adviced to use more than 10 buckets.

SizeBuckets

This works the same as the DurationBuckets but for the metric that measures the size of the responses. It's measured in bytes and by default goes from 1B to 1GB.

Registry

The Prometheus registry to use, by default it will use Prometheus global registry (the default one on Prometheus library).

Label names

The label names of the Prometheus metrics can be configured using HandlerIDLabel, StatusCodeLabel, MethodLabel...

OpenCensus recorder options

DurationBuckets

Same option as the Prometheus recorder.

SizeBuckets

Same option as the Prometheus recorder.

Label names

Same options as the Prometheus recorder.

UnregisterViewsBeforeRegister

This Option is used to unregister the Recorder views before are being registered, this is option is mainly due to the nature of OpenCensus implementation and the huge usage fo global state making impossible to run multiple tests. On regular usage of the library this setting is very rare that needs to be used.

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].