package metrics import ( "fmt" "reflect" "sort" "strings" "sync" ) // DuplicateMetric is the error returned by Registry. Register when a metric // already exists. If you mean to Register that metric you must first // Unregister the existing metric. type DuplicateMetric string func (err DuplicateMetric) Error() string { return fmt.Sprintf("duplicate metric: %s", string(err)) } // A Registry holds references to a set of metrics by name and can iterate // over them, calling callback functions provided by the user. // // This is an interface to encourage other structs to implement // the Registry API as appropriate. type Registry interface { // Each call the given function for each registered metric. Each(func(string, interface{})) // Get the metric by the given name or nil if none is registered. Get(string) interface{} // GetAll metrics in the Registry. GetAll() map[string]map[string]interface{} // GetOrRegister gets an existing metric or registers the given one. // The interface can be the metric to register if not found in registry, // or a function returning the metric for lazy instantiation. GetOrRegister(string, interface{}) interface{} // Register the given metric under the given name. Register(string, interface{}) error // RunHealthchecks run all registered healthchecks. RunHealthchecks() // Unregister the metric with the given name. Unregister(string) } type orderedRegistry struct { StandardRegistry } // Each call the given function for each registered metric. func (r *orderedRegistry) Each(f func(string, interface{})) { var names []string reg := r.registered() for name := range reg { names = append(names, name) } sort.Strings(names) for _, name := range names { f(name, reg[name]) } } // NewRegistry creates a new registry. func NewRegistry() Registry { return new(StandardRegistry) } // NewOrderedRegistry creates a new ordered registry (for testing). func NewOrderedRegistry() Registry { return new(orderedRegistry) } // StandardRegistry the standard implementation of a Registry uses sync.map // of names to metrics. type StandardRegistry struct { metrics sync.Map } // Each call the given function for each registered metric. func (r *StandardRegistry) Each(f func(string, interface{})) { for name, i := range r.registered() { f(name, i) } } // Get the metric by the given name or nil if none is registered. func (r *StandardRegistry) Get(name string) interface{} { item, _ := r.metrics.Load(name) return item } // GetOrRegister gets an existing metric or creates and registers a new one. Threadsafe // alternative to calling Get and Register on failure. // The interface can be the metric to register if not found in registry, // or a function returning the metric for lazy instantiation. func (r *StandardRegistry) GetOrRegister(name string, i interface{}) interface{} { // fast path cached, ok := r.metrics.Load(name) if ok { return cached } if v := reflect.ValueOf(i); v.Kind() == reflect.Func { i = v.Call(nil)[0].Interface() } item, _, ok := r.loadOrRegister(name, i) if !ok { return i } return item } // Register the given metric under the given name. Returns a DuplicateMetric // if a metric by the given name is already registered. func (r *StandardRegistry) Register(name string, i interface{}) error { // fast path _, ok := r.metrics.Load(name) if ok { return DuplicateMetric(name) } if v := reflect.ValueOf(i); v.Kind() == reflect.Func { i = v.Call(nil)[0].Interface() } _, loaded, _ := r.loadOrRegister(name, i) if loaded { return DuplicateMetric(name) } return nil } // RunHealthchecks run all registered healthchecks. func (r *StandardRegistry) RunHealthchecks() { r.metrics.Range(func(key, value any) bool { if h, ok := value.(Healthcheck); ok { h.Check() } return true }) } // GetAll metrics in the Registry func (r *StandardRegistry) GetAll() map[string]map[string]interface{} { data := make(map[string]map[string]interface{}) r.Each(func(name string, i interface{}) { values := make(map[string]interface{}) switch metric := i.(type) { case Counter: values["count"] = metric.Snapshot().Count() case CounterFloat64: values["count"] = metric.Snapshot().Count() case Gauge: values["value"] = metric.Snapshot().Value() case GaugeFloat64: values["value"] = metric.Snapshot().Value() case Healthcheck: values["error"] = nil metric.Check() if err := metric.Error(); nil != err { values["error"] = metric.Error().Error() } case Histogram: h := metric.Snapshot() ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) values["count"] = h.Count() values["min"] = h.Min() values["max"] = h.Max() values["mean"] = h.Mean() values["stddev"] = h.StdDev() values["median"] = ps[0] values["75%"] = ps[1] values["95%"] = ps[2] values["99%"] = ps[3] values["99.9%"] = ps[4] case Meter: m := metric.Snapshot() values["count"] = m.Count() values["1m.rate"] = m.Rate1() values["5m.rate"] = m.Rate5() values["15m.rate"] = m.Rate15() values["mean.rate"] = m.RateMean() case Timer: t := metric.Snapshot() ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) values["count"] = t.Count() values["min"] = t.Min() values["max"] = t.Max() values["mean"] = t.Mean() values["stddev"] = t.StdDev() values["median"] = ps[0] values["75%"] = ps[1] values["95%"] = ps[2] values["99%"] = ps[3] values["99.9%"] = ps[4] values["1m.rate"] = t.Rate1() values["5m.rate"] = t.Rate5() values["15m.rate"] = t.Rate15() values["mean.rate"] = t.RateMean() } data[name] = values }) return data } // Unregister the metric with the given name. func (r *StandardRegistry) Unregister(name string) { r.stop(name) r.metrics.LoadAndDelete(name) } func (r *StandardRegistry) loadOrRegister(name string, i interface{}) (interface{}, bool, bool) { switch i.(type) { case Counter, CounterFloat64, Gauge, GaugeFloat64, GaugeInfo, Healthcheck, Histogram, Meter, Timer, ResettingTimer: default: return nil, false, false } item, loaded := r.metrics.LoadOrStore(name, i) return item, loaded, true } func (r *StandardRegistry) registered() map[string]interface{} { metrics := make(map[string]interface{}) r.metrics.Range(func(key, value any) bool { metrics[key.(string)] = value return true }) return metrics } func (r *StandardRegistry) stop(name string) { if i, ok := r.metrics.Load(name); ok { if s, ok := i.(Stoppable); ok { s.Stop() } } } // Stoppable defines the metrics which has to be stopped. type Stoppable interface { Stop() } type PrefixedRegistry struct { underlying Registry prefix string } func NewPrefixedRegistry(prefix string) Registry { return &PrefixedRegistry{ underlying: NewRegistry(), prefix: prefix, } } func NewPrefixedChildRegistry(parent Registry, prefix string) Registry { return &PrefixedRegistry{ underlying: parent, prefix: prefix, } } // Each call the given function for each registered metric. func (r *PrefixedRegistry) Each(fn func(string, interface{})) { wrappedFn := func(prefix string) func(string, interface{}) { return func(name string, iface interface{}) { if strings.HasPrefix(name, prefix) { fn(name, iface) } else { return } } } baseRegistry, prefix := findPrefix(r, "") baseRegistry.Each(wrappedFn(prefix)) } func findPrefix(registry Registry, prefix string) (Registry, string) { switch r := registry.(type) { case *PrefixedRegistry: return findPrefix(r.underlying, r.prefix+prefix) case *StandardRegistry: return r, prefix } return nil, "" } // Get the metric by the given name or nil if none is registered. func (r *PrefixedRegistry) Get(name string) interface{} { realName := r.prefix + name return r.underlying.Get(realName) } // GetOrRegister gets an existing metric or registers the given one. // The interface can be the metric to register if not found in registry, // or a function returning the metric for lazy instantiation. func (r *PrefixedRegistry) GetOrRegister(name string, metric interface{}) interface{} { realName := r.prefix + name return r.underlying.GetOrRegister(realName, metric) } // Register the given metric under the given name. The name will be prefixed. func (r *PrefixedRegistry) Register(name string, metric interface{}) error { realName := r.prefix + name return r.underlying.Register(realName, metric) } // RunHealthchecks run all registered healthchecks. func (r *PrefixedRegistry) RunHealthchecks() { r.underlying.RunHealthchecks() } // GetAll metrics in the Registry func (r *PrefixedRegistry) GetAll() map[string]map[string]interface{} { return r.underlying.GetAll() } // Unregister the metric with the given name. The name will be prefixed. func (r *PrefixedRegistry) Unregister(name string) { realName := r.prefix + name r.underlying.Unregister(realName) } var ( DefaultRegistry = NewRegistry() EphemeralRegistry = NewRegistry() AccountingRegistry = NewRegistry() // registry used in swarm ) // Each call the given function for each registered metric. func Each(f func(string, interface{})) { DefaultRegistry.Each(f) } // Get the metric by the given name or nil if none is registered. func Get(name string) interface{} { return DefaultRegistry.Get(name) } // GetOrRegister gets an existing metric or creates and registers a new one. Threadsafe // alternative to calling Get and Register on failure. func GetOrRegister(name string, i interface{}) interface{} { return DefaultRegistry.GetOrRegister(name, i) } // Register the given metric under the given name. Returns a DuplicateMetric // if a metric by the given name is already registered. func Register(name string, i interface{}) error { return DefaultRegistry.Register(name, i) } // MustRegister register the given metric under the given name. Panics if a metric by the // given name is already registered. func MustRegister(name string, i interface{}) { if err := Register(name, i); err != nil { panic(err) } } // RunHealthchecks run all registered healthchecks. func RunHealthchecks() { DefaultRegistry.RunHealthchecks() } // Unregister the metric with the given name. func Unregister(name string) { DefaultRegistry.Unregister(name) }