metrics.go

package metrics

import (
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/alexfalkowski/go-service/telemetry/metrics"
	ss "github.com/alexfalkowski/go-service/transport/strings"
	snoop "github.com/felixge/httpsnoop"
	"go.opentelemetry.io/otel/metric"
)

// NewHandler for metrics.
func NewHandler(meter metric.Meter) *Handler {
	started := metrics.MustInt64Counter(meter, "http_server_started_total", "Total number of RPCs started on the server.")
	received := metrics.MustInt64Counter(meter, "http_server_msg_received_total", "Total number of RPC messages received on the server.")
	sent := metrics.MustInt64Counter(meter, "http_server_msg_sent_total", "Total number of RPC messages sent by the server.")
	handled := metrics.MustInt64Counter(meter, "http_server_handled_total", "Total number of RPCs completed on the server, regardless of success or failure.")
	handledHist := metrics.MustFloat64Histogram(meter, "http_server_handling_seconds",
		"Histogram of response latency (seconds) of HTTP that had been application-level handled by the server.")

	h := &Handler{
		started: started, received: received,
		sent: sent, handled: handled,
		handledHist: handledHist,
	}

	return h
}

// Handler for metrics.
type Handler struct {
	started     metric.Int64Counter
	received    metric.Int64Counter
	sent        metric.Int64Counter
	handled     metric.Int64Counter
	handledHist metric.Float64Histogram
}

// ServeHTTP for metrics.
func (h *Handler) ServeHTTP(resp http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	service, method := req.URL.Path, strings.ToLower(req.Method)
	if ss.IsHealth(service) {
		next(resp, req)

		return
	}

	opts := metric.WithAttributes(
		serviceAttribute.String(service),
		methodAttribute.String(method),
	)

	start := time.Now()
	ctx := req.Context()

	h.started.Add(ctx, 1, opts)
	h.received.Add(ctx, 1, opts)

	m := snoop.CaptureMetricsFn(resp, func(res http.ResponseWriter) { next(res, req.WithContext(ctx)) })

	if m.Code >= 200 && m.Code <= 299 {
		h.sent.Add(ctx, 1, opts)
	}

	h.handled.Add(ctx, 1, opts, metric.WithAttributes(statusCodeAttribute.String(strconv.Itoa(m.Code))))
	h.handledHist.Record(ctx, time.Since(start).Seconds(), opts)
}

// NewRoundTripper for metrics.
func NewRoundTripper(meter metric.Meter, r http.RoundTripper) *RoundTripper {
	started := metrics.MustInt64Counter(meter, "http_client_started_total", "Total number of RPCs started on the client.")
	received := metrics.MustInt64Counter(meter, "http_client_msg_received_total", "Total number of RPC messages received on the client.")
	sent := metrics.MustInt64Counter(meter, "http_client_msg_sent_total", "Total number of RPC messages sent by the client.")
	handled := metrics.MustInt64Counter(meter, "http_client_handled_total", "Total number of RPCs completed on the client, regardless of success or failure.")
	handledHist := metrics.MustFloat64Histogram(meter, "http_client_handling_seconds",
		"Histogram of response latency (seconds) of HTTP that had been application-level handled by the client.")

	rt := &RoundTripper{
		started: started, received: received, sent: sent, handled: handled, handledHist: handledHist,
		RoundTripper: r,
	}

	return rt
}

// RoundTripper for metrics.
type RoundTripper struct {
	started     metric.Int64Counter
	received    metric.Int64Counter
	sent        metric.Int64Counter
	handled     metric.Int64Counter
	handledHist metric.Float64Histogram

	http.RoundTripper
}

// RoundTrip for metrics.
func (r *RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	if ss.IsHealth(req.URL.String()) {
		return r.RoundTripper.RoundTrip(req)
	}

	service, method := req.URL.Hostname(), strings.ToLower(req.Method)
	start := time.Now()
	ctx := req.Context()

	opts := metric.WithAttributes(
		serviceAttribute.String(service),
		methodAttribute.String(method),
	)

	r.started.Add(ctx, 1, opts)
	r.sent.Add(ctx, 1, opts)

	resp, err := r.RoundTripper.RoundTrip(req)
	if err != nil {
		return nil, err
	}

	r.received.Add(ctx, 1, opts)
	r.handled.Add(ctx, 1, opts, metric.WithAttributes(statusCodeAttribute.String(strconv.Itoa(resp.StatusCode))))
	r.handledHist.Record(ctx, time.Since(start).Seconds(), opts)

	return resp, nil
}