mirror of
https://github.com/etcd-io/etcd.git
synced 2024-09-27 06:25:44 +00:00
112 lines
2.9 KiB
Go
112 lines
2.9 KiB
Go
/*
|
|
Copyright 2014 CoreOS, Inc.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
// Package metrics provides metrics view of variables which is exposed through
|
|
// expvar package.
|
|
//
|
|
// Naming conventions:
|
|
// 1. volatile path components should be kept as deep into the hierarchy as possible
|
|
// 2. each path component should have a clear and well-defined purpose
|
|
// 3. components.separated.with.dot, and put package prefix at the head
|
|
// 4. words_separated_with_underscore, and put clarifiers last, e.g., requests_total
|
|
package metrics
|
|
|
|
import (
|
|
"bytes"
|
|
"expvar"
|
|
"fmt"
|
|
)
|
|
|
|
// Counter is a number that increases over time monotonically.
|
|
type Counter struct{ i *expvar.Int }
|
|
|
|
func NewCounter(name string) *Counter {
|
|
return &Counter{i: expvar.NewInt(name)}
|
|
}
|
|
|
|
func (c *Counter) Add() { c.i.Add(1) }
|
|
|
|
func (c *Counter) AddBy(delta int64) { c.i.Add(delta) }
|
|
|
|
func (c *Counter) String() string { return c.i.String() }
|
|
|
|
// Gauge returns instantaneous value that is expected to fluctuate over time.
|
|
type Gauge struct{ i *expvar.Int }
|
|
|
|
func NewGauge(name string) *Gauge {
|
|
return &Gauge{i: expvar.NewInt(name)}
|
|
}
|
|
|
|
func (g *Gauge) Set(value int64) { g.i.Set(value) }
|
|
|
|
func (g *Gauge) String() string { return g.i.String() }
|
|
|
|
type nilVar struct{}
|
|
|
|
func (v *nilVar) String() string { return "nil" }
|
|
|
|
// Map aggregates Counters and Gauges.
|
|
type Map struct{ *expvar.Map }
|
|
|
|
func NewMap(name string) *Map {
|
|
return &Map{Map: expvar.NewMap(name)}
|
|
}
|
|
|
|
// GetMap returns the map if it exists, or inits the given name map if it does
|
|
// not exist.
|
|
func GetMap(name string) *Map {
|
|
if m, ok := expvar.Get(name).(*expvar.Map); ok {
|
|
return &Map{Map: m}
|
|
}
|
|
return NewMap(name)
|
|
}
|
|
|
|
func (m *Map) NewCounter(key string) *Counter {
|
|
c := &Counter{i: new(expvar.Int)}
|
|
m.Set(key, c)
|
|
return c
|
|
}
|
|
|
|
func (m *Map) NewGauge(key string) *Gauge {
|
|
g := &Gauge{i: new(expvar.Int)}
|
|
m.Set(key, g)
|
|
return g
|
|
}
|
|
|
|
// TODO: remove the var from the map to avoid memory boom
|
|
func (m *Map) Delete(key string) { m.Set(key, &nilVar{}) }
|
|
|
|
// String returns JSON format string that represents the group.
|
|
// It does not print out nilVar.
|
|
func (m *Map) String() string {
|
|
var b bytes.Buffer
|
|
fmt.Fprintf(&b, "{")
|
|
first := true
|
|
m.Do(func(kv expvar.KeyValue) {
|
|
v := kv.Value.String()
|
|
if v == "nil" {
|
|
return
|
|
}
|
|
if !first {
|
|
fmt.Fprintf(&b, ", ")
|
|
}
|
|
fmt.Fprintf(&b, "%q: %v", kv.Key, v)
|
|
first = false
|
|
})
|
|
fmt.Fprintf(&b, "}")
|
|
return b.String()
|
|
}
|