This splits Prometheus metric handlers exposed by tsweb into two modules: - `varz.Handler` exposes Prometheus metrics generated by our expvar converter; - `promvarz.Handler` combines our expvar-converted metrics and native Prometheus metrics. By default, tsweb will use the promvarz handler, however users can keep using only the expvar converter. Specifically, `tailscaled` now uses `varz.Handler` explicitly, which avoids a dependency on the (heavyweight) Prometheus client. Updates https://github.com/tailscale/corp/issues/10205 Signed-off-by: Anton Tolchanov <anton@tailscale.com>main
Anton Tolchanov
3 years ago
committed by
Anton Tolchanov
parent
c153e6ae2f
commit
8546ff98fb
@ -0,0 +1,48 @@ |
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
// Package promvarz combines Prometheus metrics exported by our expvar converter
|
||||
// (tsweb/varz) with metrics exported by the official Prometheus client.
|
||||
package promvarz |
||||
|
||||
import ( |
||||
"fmt" |
||||
"net/http" |
||||
|
||||
"github.com/prometheus/client_golang/prometheus" |
||||
"github.com/prometheus/common/expfmt" |
||||
"tailscale.com/tsweb/varz" |
||||
) |
||||
|
||||
// Handler returns Prometheus metrics exported by our expvar converter
|
||||
// and the official Prometheus client.
|
||||
func Handler(w http.ResponseWriter, r *http.Request) { |
||||
if err := gatherNativePrometheusMetrics(w); err != nil { |
||||
w.WriteHeader(http.StatusInternalServerError) |
||||
w.Write([]byte(err.Error())) |
||||
return |
||||
} |
||||
varz.Handler(w, r) |
||||
} |
||||
|
||||
// gatherNativePrometheusMetrics writes metrics from the default
|
||||
// metric registry in text format.
|
||||
func gatherNativePrometheusMetrics(w http.ResponseWriter) error { |
||||
enc := expfmt.NewEncoder(w, expfmt.FmtText) |
||||
mfs, err := prometheus.DefaultGatherer.Gather() |
||||
if err != nil { |
||||
return fmt.Errorf("could not gather metrics from DefaultGatherer: %w", err) |
||||
} |
||||
|
||||
for _, mf := range mfs { |
||||
if err := enc.Encode(mf); err != nil { |
||||
return fmt.Errorf("could not encode metric %v: %w", mf, err) |
||||
} |
||||
} |
||||
if closer, ok := enc.(expfmt.Closer); ok { |
||||
if err := closer.Close(); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
@ -0,0 +1,35 @@ |
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
package promvarz |
||||
|
||||
import ( |
||||
"expvar" |
||||
"net/http" |
||||
"net/http/httptest" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"github.com/prometheus/client_golang/prometheus" |
||||
"github.com/prometheus/client_golang/prometheus/promauto" |
||||
"github.com/prometheus/client_golang/prometheus/testutil" |
||||
) |
||||
|
||||
func TestHandler(t *testing.T) { |
||||
test1 := expvar.NewInt("gauge_promvarz_test_expvar") |
||||
test1.Set(42) |
||||
test2 := promauto.NewGauge(prometheus.GaugeOpts{Name: "promvarz_test_native"}) |
||||
test2.Set(4242) |
||||
|
||||
svr := httptest.NewServer(http.HandlerFunc(Handler)) |
||||
defer svr.Close() |
||||
|
||||
want := ` |
||||
# TYPE promvarz_test_expvar gauge |
||||
promvarz_test_expvar 42 |
||||
# TYPE promvarz_test_native gauge |
||||
promvarz_test_native 4242 |
||||
` |
||||
if err := testutil.ScrapeAndCompare(svr.URL, strings.NewReader(want), "promvarz_test_expvar", "promvarz_test_native"); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
@ -0,0 +1,372 @@ |
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
// Package varz contains code to export metrics in Prometheus format.
|
||||
package varz |
||||
|
||||
import ( |
||||
"expvar" |
||||
"fmt" |
||||
"io" |
||||
"net/http" |
||||
_ "net/http/pprof" |
||||
"reflect" |
||||
"runtime" |
||||
"sort" |
||||
"strings" |
||||
"sync" |
||||
"time" |
||||
|
||||
"tailscale.com/metrics" |
||||
"tailscale.com/version" |
||||
) |
||||
|
||||
func init() { |
||||
expvar.Publish("process_start_unix_time", expvar.Func(func() any { return timeStart.Unix() })) |
||||
expvar.Publish("version", expvar.Func(func() any { return version.Long() })) |
||||
expvar.Publish("go_version", expvar.Func(func() any { return runtime.Version() })) |
||||
expvar.Publish("counter_uptime_sec", expvar.Func(func() any { return int64(Uptime().Seconds()) })) |
||||
expvar.Publish("gauge_goroutines", expvar.Func(func() any { return runtime.NumGoroutine() })) |
||||
} |
||||
|
||||
const ( |
||||
gaugePrefix = "gauge_" |
||||
counterPrefix = "counter_" |
||||
labelMapPrefix = "labelmap_" |
||||
) |
||||
|
||||
// prefixesToTrim contains key prefixes to remove when exporting and sorting metrics.
|
||||
var prefixesToTrim = []string{gaugePrefix, counterPrefix, labelMapPrefix} |
||||
|
||||
var timeStart = time.Now() |
||||
|
||||
func Uptime() time.Duration { return time.Since(timeStart).Round(time.Second) } |
||||
|
||||
// WritePrometheusExpvar writes kv to w in Prometheus metrics format.
|
||||
//
|
||||
// See VarzHandler for conventions. This is exported primarily for
|
||||
// people to test their varz.
|
||||
func WritePrometheusExpvar(w io.Writer, kv expvar.KeyValue) { |
||||
writePromExpVar(w, "", kv) |
||||
} |
||||
|
||||
type prometheusMetricDetails struct { |
||||
Name string |
||||
Type string |
||||
Label string |
||||
} |
||||
|
||||
var prometheusMetricCache sync.Map // string => *prometheusMetricDetails
|
||||
|
||||
func prometheusMetric(prefix string, key string) (string, string, string) { |
||||
cachekey := prefix + key |
||||
if v, ok := prometheusMetricCache.Load(cachekey); ok { |
||||
d := v.(*prometheusMetricDetails) |
||||
return d.Name, d.Type, d.Label |
||||
} |
||||
var typ string |
||||
var label string |
||||
switch { |
||||
case strings.HasPrefix(key, gaugePrefix): |
||||
typ = "gauge" |
||||
key = strings.TrimPrefix(key, gaugePrefix) |
||||
|
||||
case strings.HasPrefix(key, counterPrefix): |
||||
typ = "counter" |
||||
key = strings.TrimPrefix(key, counterPrefix) |
||||
} |
||||
if strings.HasPrefix(key, labelMapPrefix) { |
||||
key = strings.TrimPrefix(key, labelMapPrefix) |
||||
if a, b, ok := strings.Cut(key, "_"); ok { |
||||
label, key = a, b |
||||
} |
||||
} |
||||
d := &prometheusMetricDetails{ |
||||
Name: strings.ReplaceAll(prefix+key, "-", "_"), |
||||
Type: typ, |
||||
Label: label, |
||||
} |
||||
prometheusMetricCache.Store(cachekey, d) |
||||
return d.Name, d.Type, d.Label |
||||
} |
||||
|
||||
func writePromExpVar(w io.Writer, prefix string, kv expvar.KeyValue) { |
||||
key := kv.Key |
||||
name, typ, label := prometheusMetric(prefix, key) |
||||
|
||||
switch v := kv.Value.(type) { |
||||
case *expvar.Int: |
||||
if typ == "" { |
||||
typ = "counter" |
||||
} |
||||
fmt.Fprintf(w, "# TYPE %s %s\n%s %v\n", name, typ, name, v.Value()) |
||||
return |
||||
case *expvar.Float: |
||||
if typ == "" { |
||||
typ = "gauge" |
||||
} |
||||
fmt.Fprintf(w, "# TYPE %s %s\n%s %v\n", name, typ, name, v.Value()) |
||||
return |
||||
case *metrics.Set: |
||||
v.Do(func(kv expvar.KeyValue) { |
||||
writePromExpVar(w, name+"_", kv) |
||||
}) |
||||
return |
||||
case PrometheusMetricsReflectRooter: |
||||
root := v.PrometheusMetricsReflectRoot() |
||||
rv := reflect.ValueOf(root) |
||||
if rv.Type().Kind() == reflect.Ptr { |
||||
if rv.IsNil() { |
||||
return |
||||
} |
||||
rv = rv.Elem() |
||||
} |
||||
if rv.Type().Kind() != reflect.Struct { |
||||
fmt.Fprintf(w, "# skipping expvar %q; unknown root type\n", name) |
||||
return |
||||
} |
||||
foreachExportedStructField(rv, func(fieldOrJSONName, metricType string, rv reflect.Value) { |
||||
mname := name + "_" + fieldOrJSONName |
||||
switch rv.Kind() { |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
fmt.Fprintf(w, "# TYPE %s %s\n%s %v\n", mname, metricType, mname, rv.Int()) |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: |
||||
fmt.Fprintf(w, "# TYPE %s %s\n%s %v\n", mname, metricType, mname, rv.Uint()) |
||||
case reflect.Float32, reflect.Float64: |
||||
fmt.Fprintf(w, "# TYPE %s %s\n%s %v\n", mname, metricType, mname, rv.Float()) |
||||
case reflect.Struct: |
||||
if rv.CanAddr() { |
||||
// Slight optimization, not copying big structs if they're addressable:
|
||||
writePromExpVar(w, name+"_", expvar.KeyValue{Key: fieldOrJSONName, Value: expVarPromStructRoot{rv.Addr().Interface()}}) |
||||
} else { |
||||
writePromExpVar(w, name+"_", expvar.KeyValue{Key: fieldOrJSONName, Value: expVarPromStructRoot{rv.Interface()}}) |
||||
} |
||||
} |
||||
return |
||||
}) |
||||
return |
||||
} |
||||
|
||||
if typ == "" { |
||||
var funcRet string |
||||
if f, ok := kv.Value.(expvar.Func); ok { |
||||
v := f() |
||||
if ms, ok := v.(runtime.MemStats); ok && name == "memstats" { |
||||
writeMemstats(w, &ms) |
||||
return |
||||
} |
||||
if vs, ok := v.(string); ok && strings.HasSuffix(name, "version") { |
||||
fmt.Fprintf(w, "%s{version=%q} 1\n", name, vs) |
||||
return |
||||
} |
||||
switch v := v.(type) { |
||||
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64: |
||||
fmt.Fprintf(w, "%s %v\n", name, v) |
||||
return |
||||
} |
||||
funcRet = fmt.Sprintf(" returning %T", v) |
||||
} |
||||
switch kv.Value.(type) { |
||||
default: |
||||
fmt.Fprintf(w, "# skipping expvar %q (Go type %T%s) with undeclared Prometheus type\n", name, kv.Value, funcRet) |
||||
return |
||||
case *metrics.LabelMap, *expvar.Map: |
||||
// Permit typeless LabelMap and expvar.Map for
|
||||
// compatibility with old expvar-registered
|
||||
// metrics.LabelMap.
|
||||
} |
||||
} |
||||
|
||||
switch v := kv.Value.(type) { |
||||
case expvar.Func: |
||||
val := v() |
||||
switch val.(type) { |
||||
case float64, int64, int: |
||||
fmt.Fprintf(w, "# TYPE %s %s\n%s %v\n", name, typ, name, val) |
||||
default: |
||||
fmt.Fprintf(w, "# skipping expvar func %q returning unknown type %T\n", name, val) |
||||
} |
||||
|
||||
case *metrics.LabelMap: |
||||
if typ != "" { |
||||
fmt.Fprintf(w, "# TYPE %s %s\n", name, typ) |
||||
} |
||||
// IntMap uses expvar.Map on the inside, which presorts
|
||||
// keys. The output ordering is deterministic.
|
||||
v.Do(func(kv expvar.KeyValue) { |
||||
fmt.Fprintf(w, "%s{%s=%q} %v\n", name, v.Label, kv.Key, kv.Value) |
||||
}) |
||||
case *expvar.Map: |
||||
if label != "" && typ != "" { |
||||
fmt.Fprintf(w, "# TYPE %s %s\n", name, typ) |
||||
v.Do(func(kv expvar.KeyValue) { |
||||
fmt.Fprintf(w, "%s{%s=%q} %v\n", name, label, kv.Key, kv.Value) |
||||
}) |
||||
} else { |
||||
v.Do(func(kv expvar.KeyValue) { |
||||
fmt.Fprintf(w, "%s_%s %v\n", name, kv.Key, kv.Value) |
||||
}) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var sortedKVsPool = &sync.Pool{New: func() any { return new(sortedKVs) }} |
||||
|
||||
// sortedKV is a KeyValue with a sort key.
|
||||
type sortedKV struct { |
||||
expvar.KeyValue |
||||
sortKey string // KeyValue.Key with type prefix removed
|
||||
} |
||||
|
||||
type sortedKVs struct { |
||||
kvs []sortedKV |
||||
} |
||||
|
||||
// Handler is an HTTP handler to write expvar values into the
|
||||
// prometheus export format:
|
||||
//
|
||||
// https://github.com/prometheus/docs/blob/master/content/docs/instrumenting/exposition_formats.md
|
||||
//
|
||||
// It makes the following assumptions:
|
||||
//
|
||||
// - *expvar.Int are counters (unless marked as a gauge_; see below)
|
||||
// - a *tailscale/metrics.Set is descended into, joining keys with
|
||||
// underscores. So use underscores as your metric names.
|
||||
// - an expvar named starting with "gauge_" or "counter_" is of that
|
||||
// Prometheus type, and has that prefix stripped.
|
||||
// - anything else is untyped and thus not exported.
|
||||
// - expvar.Func can return an int or int64 (for now) and anything else
|
||||
// is not exported.
|
||||
//
|
||||
// This will evolve over time, or perhaps be replaced.
|
||||
func Handler(w http.ResponseWriter, r *http.Request) { |
||||
w.Header().Set("Content-Type", "text/plain; version=0.0.4") |
||||
|
||||
s := sortedKVsPool.Get().(*sortedKVs) |
||||
defer sortedKVsPool.Put(s) |
||||
s.kvs = s.kvs[:0] |
||||
expvarDo(func(kv expvar.KeyValue) { |
||||
s.kvs = append(s.kvs, sortedKV{kv, removeTypePrefixes(kv.Key)}) |
||||
}) |
||||
sort.Slice(s.kvs, func(i, j int) bool { |
||||
return s.kvs[i].sortKey < s.kvs[j].sortKey |
||||
}) |
||||
for _, e := range s.kvs { |
||||
writePromExpVar(w, "", e.KeyValue) |
||||
} |
||||
} |
||||
|
||||
// PrometheusMetricsReflectRooter is an optional interface that expvar.Var implementations
|
||||
// can implement to indicate that they should be walked recursively with reflect to find
|
||||
// sets of fields to export.
|
||||
type PrometheusMetricsReflectRooter interface { |
||||
expvar.Var |
||||
|
||||
// PrometheusMetricsReflectRoot returns the struct or struct pointer to walk.
|
||||
PrometheusMetricsReflectRoot() any |
||||
} |
||||
|
||||
var expvarDo = expvar.Do // pulled out for tests
|
||||
|
||||
func writeMemstats(w io.Writer, ms *runtime.MemStats) { |
||||
out := func(name, typ string, v uint64, help string) { |
||||
if help != "" { |
||||
fmt.Fprintf(w, "# HELP memstats_%s %s\n", name, help) |
||||
} |
||||
fmt.Fprintf(w, "# TYPE memstats_%s %s\nmemstats_%s %v\n", name, typ, name, v) |
||||
} |
||||
g := func(name string, v uint64, help string) { out(name, "gauge", v, help) } |
||||
c := func(name string, v uint64, help string) { out(name, "counter", v, help) } |
||||
g("heap_alloc", ms.HeapAlloc, "current bytes of allocated heap objects (up/down smoothly)") |
||||
c("total_alloc", ms.TotalAlloc, "cumulative bytes allocated for heap objects") |
||||
g("sys", ms.Sys, "total bytes of memory obtained from the OS") |
||||
c("mallocs", ms.Mallocs, "cumulative count of heap objects allocated") |
||||
c("frees", ms.Frees, "cumulative count of heap objects freed") |
||||
c("num_gc", uint64(ms.NumGC), "number of completed GC cycles") |
||||
} |
||||
|
||||
// sortedStructField is metadata about a struct field used both for sorting once
|
||||
// (by structTypeSortedFields) and at serving time (by
|
||||
// foreachExportedStructField).
|
||||
type sortedStructField struct { |
||||
Index int // index of struct field in struct
|
||||
Name string // struct field name, or "json" name
|
||||
SortName string // Name with "foo_" type prefixes removed
|
||||
MetricType string // the "metrictype" struct tag
|
||||
StructFieldType *reflect.StructField |
||||
} |
||||
|
||||
var structSortedFieldsCache sync.Map // reflect.Type => []sortedStructField
|
||||
|
||||
// structTypeSortedFields returns the sorted fields of t, caching as needed.
|
||||
func structTypeSortedFields(t reflect.Type) []sortedStructField { |
||||
if v, ok := structSortedFieldsCache.Load(t); ok { |
||||
return v.([]sortedStructField) |
||||
} |
||||
fields := make([]sortedStructField, 0, t.NumField()) |
||||
for i, n := 0, t.NumField(); i < n; i++ { |
||||
sf := t.Field(i) |
||||
name := sf.Name |
||||
if v := sf.Tag.Get("json"); v != "" { |
||||
v, _, _ = strings.Cut(v, ",") |
||||
if v == "-" { |
||||
// Skip it, regardless of its metrictype.
|
||||
continue |
||||
} |
||||
if v != "" { |
||||
name = v |
||||
} |
||||
} |
||||
fields = append(fields, sortedStructField{ |
||||
Index: i, |
||||
Name: name, |
||||
SortName: removeTypePrefixes(name), |
||||
MetricType: sf.Tag.Get("metrictype"), |
||||
StructFieldType: &sf, |
||||
}) |
||||
} |
||||
sort.Slice(fields, func(i, j int) bool { |
||||
return fields[i].SortName < fields[j].SortName |
||||
}) |
||||
structSortedFieldsCache.Store(t, fields) |
||||
return fields |
||||
} |
||||
|
||||
// removeTypePrefixes returns s with the first "foo_" prefix in prefixesToTrim
|
||||
// removed.
|
||||
func removeTypePrefixes(s string) string { |
||||
for _, prefix := range prefixesToTrim { |
||||
if trimmed, ok := strings.CutPrefix(s, prefix); ok { |
||||
return trimmed |
||||
} |
||||
} |
||||
return s |
||||
} |
||||
|
||||
// foreachExportedStructField iterates over the fields in sorted order of
|
||||
// their name, after removing metric prefixes. This is not necessarily the
|
||||
// order they were declared in the struct
|
||||
func foreachExportedStructField(rv reflect.Value, f func(fieldOrJSONName, metricType string, rv reflect.Value)) { |
||||
t := rv.Type() |
||||
for _, ssf := range structTypeSortedFields(t) { |
||||
sf := ssf.StructFieldType |
||||
if ssf.MetricType != "" || sf.Type.Kind() == reflect.Struct { |
||||
f(ssf.Name, ssf.MetricType, rv.Field(ssf.Index)) |
||||
} else if sf.Type.Kind() == reflect.Ptr && sf.Type.Elem().Kind() == reflect.Struct { |
||||
fv := rv.Field(ssf.Index) |
||||
if !fv.IsNil() { |
||||
f(ssf.Name, ssf.MetricType, fv.Elem()) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
type expVarPromStructRoot struct{ v any } |
||||
|
||||
func (r expVarPromStructRoot) PrometheusMetricsReflectRoot() any { return r.v } |
||||
func (r expVarPromStructRoot) String() string { panic("unused") } |
||||
|
||||
var ( |
||||
_ PrometheusMetricsReflectRooter = expVarPromStructRoot{} |
||||
_ expvar.Var = expVarPromStructRoot{} |
||||
) |
||||
@ -0,0 +1,375 @@ |
||||
// Copyright (c) Tailscale Inc & AUTHORS
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
|
||||
package varz |
||||
|
||||
import ( |
||||
"expvar" |
||||
"net/http/httptest" |
||||
"reflect" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"tailscale.com/metrics" |
||||
"tailscale.com/tstest" |
||||
"tailscale.com/version" |
||||
) |
||||
|
||||
func TestVarzHandler(t *testing.T) { |
||||
t.Run("globals_log", func(t *testing.T) { |
||||
rec := httptest.NewRecorder() |
||||
Handler(rec, httptest.NewRequest("GET", "/", nil)) |
||||
t.Logf("Got: %s", rec.Body.Bytes()) |
||||
}) |
||||
|
||||
half := new(expvar.Float) |
||||
half.Set(0.5) |
||||
|
||||
tests := []struct { |
||||
name string |
||||
k string // key name
|
||||
v expvar.Var |
||||
want string |
||||
}{ |
||||
{ |
||||
"int", |
||||
"foo", |
||||
new(expvar.Int), |
||||
"# TYPE foo counter\nfoo 0\n", |
||||
}, |
||||
{ |
||||
"dash_in_metric_name", |
||||
"counter_foo-bar", |
||||
new(expvar.Int), |
||||
"# TYPE foo_bar counter\nfoo_bar 0\n", |
||||
}, |
||||
{ |
||||
"int_with_type_counter", |
||||
"counter_foo", |
||||
new(expvar.Int), |
||||
"# TYPE foo counter\nfoo 0\n", |
||||
}, |
||||
{ |
||||
"int_with_type_gauge", |
||||
"gauge_foo", |
||||
new(expvar.Int), |
||||
"# TYPE foo gauge\nfoo 0\n", |
||||
}, |
||||
{ |
||||
// For a float = 0.0, Prometheus client_golang outputs "0"
|
||||
"float_zero", |
||||
"foo", |
||||
new(expvar.Float), |
||||
"# TYPE foo gauge\nfoo 0\n", |
||||
}, |
||||
{ |
||||
"float_point_5", |
||||
"foo", |
||||
half, |
||||
"# TYPE foo gauge\nfoo 0.5\n", |
||||
}, |
||||
{ |
||||
"float_with_type_counter", |
||||
"counter_foo", |
||||
half, |
||||
"# TYPE foo counter\nfoo 0.5\n", |
||||
}, |
||||
{ |
||||
"float_with_type_gauge", |
||||
"gauge_foo", |
||||
half, |
||||
"# TYPE foo gauge\nfoo 0.5\n", |
||||
}, |
||||
{ |
||||
"metrics_set", |
||||
"s", |
||||
&metrics.Set{ |
||||
Map: *(func() *expvar.Map { |
||||
m := new(expvar.Map) |
||||
m.Init() |
||||
m.Add("foo", 1) |
||||
m.Add("bar", 2) |
||||
return m |
||||
})(), |
||||
}, |
||||
"# TYPE s_bar counter\ns_bar 2\n# TYPE s_foo counter\ns_foo 1\n", |
||||
}, |
||||
{ |
||||
"metrics_set_TODO_gauge_type", |
||||
"gauge_s", // TODO(bradfitz): arguably a bug; should pass down type
|
||||
&metrics.Set{ |
||||
Map: *(func() *expvar.Map { |
||||
m := new(expvar.Map) |
||||
m.Init() |
||||
m.Add("foo", 1) |
||||
m.Add("bar", 2) |
||||
return m |
||||
})(), |
||||
}, |
||||
"# TYPE s_bar counter\ns_bar 2\n# TYPE s_foo counter\ns_foo 1\n", |
||||
}, |
||||
{ |
||||
"expvar_map_untyped", |
||||
"api_status_code", |
||||
func() *expvar.Map { |
||||
m := new(expvar.Map) |
||||
m.Init() |
||||
m.Add("2xx", 100) |
||||
m.Add("5xx", 2) |
||||
return m |
||||
}(), |
||||
"api_status_code_2xx 100\napi_status_code_5xx 2\n", |
||||
}, |
||||
{ |
||||
"func_float64", |
||||
"counter_x", |
||||
expvar.Func(func() any { return float64(1.2) }), |
||||
"# TYPE x counter\nx 1.2\n", |
||||
}, |
||||
{ |
||||
"func_float64_gauge", |
||||
"gauge_y", |
||||
expvar.Func(func() any { return float64(1.2) }), |
||||
"# TYPE y gauge\ny 1.2\n", |
||||
}, |
||||
{ |
||||
"func_float64_untyped", |
||||
"z", |
||||
expvar.Func(func() any { return float64(1.2) }), |
||||
"z 1.2\n", |
||||
}, |
||||
{ |
||||
"metrics_label_map", |
||||
"counter_m", |
||||
&metrics.LabelMap{ |
||||
Label: "label", |
||||
Map: *(func() *expvar.Map { |
||||
m := new(expvar.Map) |
||||
m.Init() |
||||
m.Add("foo", 1) |
||||
m.Add("bar", 2) |
||||
return m |
||||
})(), |
||||
}, |
||||
"# TYPE m counter\nm{label=\"bar\"} 2\nm{label=\"foo\"} 1\n", |
||||
}, |
||||
{ |
||||
"metrics_label_map_untyped", |
||||
"control_save_config", |
||||
(func() *metrics.LabelMap { |
||||
m := &metrics.LabelMap{Label: "reason"} |
||||
m.Add("new", 1) |
||||
m.Add("updated", 1) |
||||
m.Add("fun", 1) |
||||
return m |
||||
})(), |
||||
"control_save_config{reason=\"fun\"} 1\ncontrol_save_config{reason=\"new\"} 1\ncontrol_save_config{reason=\"updated\"} 1\n", |
||||
}, |
||||
{ |
||||
"expvar_label_map", |
||||
"counter_labelmap_keyname_m", |
||||
func() *expvar.Map { |
||||
m := new(expvar.Map) |
||||
m.Init() |
||||
m.Add("foo", 1) |
||||
m.Add("bar", 2) |
||||
return m |
||||
}(), |
||||
"# TYPE m counter\nm{keyname=\"bar\"} 2\nm{keyname=\"foo\"} 1\n", |
||||
}, |
||||
{ |
||||
"struct_reflect", |
||||
"foo", |
||||
someExpVarWithJSONAndPromTypes(), |
||||
strings.TrimSpace(` |
||||
# TYPE foo_AUint16 counter |
||||
foo_AUint16 65535 |
||||
# TYPE foo_AnInt8 counter |
||||
foo_AnInt8 127 |
||||
# TYPE foo_curTemp gauge |
||||
foo_curTemp 20.6 |
||||
# TYPE foo_curX gauge |
||||
foo_curX 3 |
||||
# TYPE foo_nestptr_bar counter |
||||
foo_nestptr_bar 20 |
||||
# TYPE foo_nestptr_foo gauge |
||||
foo_nestptr_foo 10 |
||||
# TYPE foo_nestvalue_bar counter |
||||
foo_nestvalue_bar 2 |
||||
# TYPE foo_nestvalue_foo gauge |
||||
foo_nestvalue_foo 1 |
||||
# TYPE foo_totalY counter |
||||
foo_totalY 4 |
||||
`) + "\n", |
||||
}, |
||||
{ |
||||
"struct_reflect_nil_root", |
||||
"foo", |
||||
expvarAdapter{(*SomeStats)(nil)}, |
||||
"", |
||||
}, |
||||
{ |
||||
"func_returning_int", |
||||
"num_goroutines", |
||||
expvar.Func(func() any { return 123 }), |
||||
"num_goroutines 123\n", |
||||
}, |
||||
{ |
||||
"string_version_var", |
||||
"foo_version", |
||||
expvar.Func(func() any { return "1.2.3-foo15" }), |
||||
"foo_version{version=\"1.2.3-foo15\"} 1\n", |
||||
}, |
||||
{ |
||||
"field_ordering", |
||||
"foo", |
||||
someExpVarWithFieldNamesSorting(), |
||||
strings.TrimSpace(` |
||||
# TYPE foo_bar_a gauge |
||||
foo_bar_a 1 |
||||
# TYPE foo_bar_b counter |
||||
foo_bar_b 1 |
||||
# TYPE foo_foo_a gauge |
||||
foo_foo_a 1 |
||||
# TYPE foo_foo_b counter |
||||
foo_foo_b 1 |
||||
`) + "\n", |
||||
}, |
||||
} |
||||
for _, tt := range tests { |
||||
t.Run(tt.name, func(t *testing.T) { |
||||
tstest.Replace(t, &expvarDo, func(f func(expvar.KeyValue)) { |
||||
f(expvar.KeyValue{Key: tt.k, Value: tt.v}) |
||||
}) |
||||
rec := httptest.NewRecorder() |
||||
Handler(rec, httptest.NewRequest("GET", "/", nil)) |
||||
if got := rec.Body.Bytes(); string(got) != tt.want { |
||||
t.Errorf("mismatch\n got: %q\n%s\nwant: %q\n%s\n", got, got, tt.want, tt.want) |
||||
} |
||||
}) |
||||
} |
||||
} |
||||
|
||||
type SomeNested struct { |
||||
FooG int64 `json:"foo" metrictype:"gauge"` |
||||
BarC int64 `json:"bar" metrictype:"counter"` |
||||
Omit int `json:"-" metrictype:"counter"` |
||||
} |
||||
|
||||
type SomeStats struct { |
||||
Nested SomeNested `json:"nestvalue"` |
||||
NestedPtr *SomeNested `json:"nestptr"` |
||||
NestedNilPtr *SomeNested `json:"nestnilptr"` |
||||
CurX int `json:"curX" metrictype:"gauge"` |
||||
NoMetricType int `json:"noMetric" metrictype:""` |
||||
TotalY int64 `json:"totalY,omitempty" metrictype:"counter"` |
||||
CurTemp float64 `json:"curTemp" metrictype:"gauge"` |
||||
AnInt8 int8 `metrictype:"counter"` |
||||
AUint16 uint16 `metrictype:"counter"` |
||||
} |
||||
|
||||
// someExpVarWithJSONAndPromTypes returns an expvar.Var that
|
||||
// implements PrometheusMetricsReflectRooter for TestVarzHandler.
|
||||
func someExpVarWithJSONAndPromTypes() expvar.Var { |
||||
st := &SomeStats{ |
||||
Nested: SomeNested{ |
||||
FooG: 1, |
||||
BarC: 2, |
||||
Omit: 3, |
||||
}, |
||||
NestedPtr: &SomeNested{ |
||||
FooG: 10, |
||||
BarC: 20, |
||||
}, |
||||
CurX: 3, |
||||
TotalY: 4, |
||||
CurTemp: 20.6, |
||||
AnInt8: 127, |
||||
AUint16: 65535, |
||||
} |
||||
return expvarAdapter{st} |
||||
} |
||||
|
||||
type expvarAdapter struct { |
||||
st *SomeStats |
||||
} |
||||
|
||||
func (expvarAdapter) String() string { return "{}" } // expvar JSON; unused in test
|
||||
|
||||
func (a expvarAdapter) PrometheusMetricsReflectRoot() any { |
||||
return a.st |
||||
} |
||||
|
||||
// SomeTestOfFieldNamesSorting demonstrates field
|
||||
// names that are not in sorted in declaration order, to verify
|
||||
// that we sort based on field name
|
||||
type SomeTestOfFieldNamesSorting struct { |
||||
FooAG int64 `json:"foo_a" metrictype:"gauge"` |
||||
BarAG int64 `json:"bar_a" metrictype:"gauge"` |
||||
FooBC int64 `json:"foo_b" metrictype:"counter"` |
||||
BarBC int64 `json:"bar_b" metrictype:"counter"` |
||||
} |
||||
|
||||
// someExpVarWithFieldNamesSorting returns an expvar.Var that
|
||||
// implements PrometheusMetricsReflectRooter for TestVarzHandler.
|
||||
func someExpVarWithFieldNamesSorting() expvar.Var { |
||||
st := &SomeTestOfFieldNamesSorting{ |
||||
FooAG: 1, |
||||
BarAG: 1, |
||||
FooBC: 1, |
||||
BarBC: 1, |
||||
} |
||||
return expvarAdapter2{st} |
||||
} |
||||
|
||||
type expvarAdapter2 struct { |
||||
st *SomeTestOfFieldNamesSorting |
||||
} |
||||
|
||||
func (expvarAdapter2) String() string { return "{}" } // expvar JSON; unused in test
|
||||
|
||||
func (a expvarAdapter2) PrometheusMetricsReflectRoot() any { |
||||
return a.st |
||||
} |
||||
|
||||
func TestSortedStructAllocs(t *testing.T) { |
||||
f := reflect.ValueOf(struct { |
||||
Foo int |
||||
Bar int |
||||
Baz int |
||||
}{}) |
||||
n := testing.AllocsPerRun(1000, func() { |
||||
foreachExportedStructField(f, func(fieldOrJSONName, metricType string, rv reflect.Value) { |
||||
// Nothing.
|
||||
}) |
||||
}) |
||||
if n != 0 { |
||||
t.Errorf("allocs = %v; want 0", n) |
||||
} |
||||
} |
||||
|
||||
func TestVarzHandlerSorting(t *testing.T) { |
||||
tstest.Replace(t, &expvarDo, func(f func(expvar.KeyValue)) { |
||||
f(expvar.KeyValue{Key: "counter_zz", Value: new(expvar.Int)}) |
||||
f(expvar.KeyValue{Key: "gauge_aa", Value: new(expvar.Int)}) |
||||
}) |
||||
rec := httptest.NewRecorder() |
||||
req := httptest.NewRequest("GET", "/", nil) |
||||
Handler(rec, req) |
||||
got := rec.Body.Bytes() |
||||
const want = "# TYPE aa gauge\naa 0\n# TYPE zz counter\nzz 0\n" |
||||
if string(got) != want { |
||||
t.Errorf("got %q; want %q", got, want) |
||||
} |
||||
rec = new(httptest.ResponseRecorder) // without a body
|
||||
|
||||
// Lock in the current number of allocs, to prevent it from growing.
|
||||
if !version.IsRace() { |
||||
allocs := int(testing.AllocsPerRun(1000, func() { |
||||
Handler(rec, req) |
||||
})) |
||||
if max := 13; allocs > max { |
||||
t.Errorf("allocs = %v; want max %v", allocs, max) |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue