9045b79bc2
This PR modifies how the metrics library handles `Enabled`: previously, the package `init` decided whether to serve real metrics or just dummy-types. This has several drawbacks: - During pkg init, we need to determine whether metrics are enabled or not. So we first hacked in a check if certain geth-specific commandline-flags were enabled. Then we added a similar check for geth-env-vars. Then we almost added a very elaborate check for toml-config-file, plus toml parsing. - Using "real" types and dummy types interchangeably means that everything is hidden behind interfaces. This has a performance penalty, and also it just adds a lot of code. This PR removes the interface stuff, uses concrete types, and allows for the setting of Enabled to happen later. It is still assumed that `metrics.Enable()` is invoked early on. The somewhat 'heavy' operations, such as ticking meters and exp-decay, now checks the enable-flag to prevent resource leak. The change may be large, but it's mostly pretty trivial, and from the last time I gutted the metrics, I ensured that we have fairly good test coverage. --------- Co-authored-by: Felix Lange <fjl@twurst.com>
70 lines
1.9 KiB
Go
70 lines
1.9 KiB
Go
package metrics
|
|
|
|
import (
|
|
"math"
|
|
"sync/atomic"
|
|
)
|
|
|
|
// GetOrRegisterCounterFloat64 returns an existing *CounterFloat64 or constructs and registers
|
|
// a new CounterFloat64.
|
|
func GetOrRegisterCounterFloat64(name string, r Registry) *CounterFloat64 {
|
|
if nil == r {
|
|
r = DefaultRegistry
|
|
}
|
|
return r.GetOrRegister(name, NewCounterFloat64).(*CounterFloat64)
|
|
}
|
|
|
|
// NewCounterFloat64 constructs a new CounterFloat64.
|
|
func NewCounterFloat64() *CounterFloat64 {
|
|
return new(CounterFloat64)
|
|
}
|
|
|
|
// NewRegisteredCounterFloat64 constructs and registers a new CounterFloat64.
|
|
func NewRegisteredCounterFloat64(name string, r Registry) *CounterFloat64 {
|
|
c := NewCounterFloat64()
|
|
if r == nil {
|
|
r = DefaultRegistry
|
|
}
|
|
r.Register(name, c)
|
|
return c
|
|
}
|
|
|
|
// CounterFloat64Snapshot is a read-only copy of a float64 counter.
|
|
type CounterFloat64Snapshot float64
|
|
|
|
// Count returns the value at the time the snapshot was taken.
|
|
func (c CounterFloat64Snapshot) Count() float64 { return float64(c) }
|
|
|
|
// CounterFloat64 holds a float64 value that can be incremented and decremented.
|
|
type CounterFloat64 atomic.Uint64
|
|
|
|
// Clear sets the counter to zero.
|
|
func (c *CounterFloat64) Clear() {
|
|
(*atomic.Uint64)(c).Store(0)
|
|
}
|
|
|
|
// Dec decrements the counter by the given amount.
|
|
func (c *CounterFloat64) Dec(v float64) {
|
|
atomicAddFloat((*atomic.Uint64)(c), -v)
|
|
}
|
|
|
|
// Inc increments the counter by the given amount.
|
|
func (c *CounterFloat64) Inc(v float64) {
|
|
atomicAddFloat((*atomic.Uint64)(c), v)
|
|
}
|
|
|
|
// Snapshot returns a read-only copy of the counter.
|
|
func (c *CounterFloat64) Snapshot() CounterFloat64Snapshot {
|
|
return CounterFloat64Snapshot(math.Float64frombits((*atomic.Uint64)(c).Load()))
|
|
}
|
|
|
|
func atomicAddFloat(fbits *atomic.Uint64, v float64) {
|
|
for {
|
|
loadedBits := fbits.Load()
|
|
newBits := math.Float64bits(math.Float64frombits(loadedBits) + v)
|
|
if fbits.CompareAndSwap(loadedBits, newBits) {
|
|
break
|
|
}
|
|
}
|
|
}
|