/
gauge_float64.go
78 lines (65 loc) · 2.16 KB
/
gauge_float64.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// Copyright 2015 The Cockroach Authors.
//
// 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 metric
import (
"math"
"sync/atomic"
"time"
"github.com/vearch/vearch/util/metrics"
)
var _ metrics.Metric = &GaugeFloat64{}
// A GaugeFloat64 atomically stores a single float64 value.
type GaugeFloat64 struct {
metrics.Metadata
value uint64
}
// NewGaugeFloat64 creates a GaugeFloat64.
func NewGaugeFloat64(metadata metrics.Metadata) *GaugeFloat64 {
return &GaugeFloat64{Metadata: metadata}
}
// GetMetadata return the metadata of Gauge.
func (g *GaugeFloat64) GetMetadata() metrics.Metadata {
return g.Metadata
}
// GetType returns the type enum for this metric.
func (g *GaugeFloat64) GetType() metrics.MetricType {
return metrics.MetricType_GAUGE
}
// Inspect calls the closure with the empty string and the receiver.
func (g *GaugeFloat64) Inspect(f func(metrics.Metric)) {
f(g)
}
// Update updates the gauge's value.
func (g *GaugeFloat64) Update(v float64) {
atomic.StoreUint64(&g.value, math.Float64bits(v))
}
// Value returns the gauge's current value.
func (g *GaugeFloat64) Value() float64 {
return math.Float64frombits(atomic.LoadUint64(&g.value))
}
// Snapshot returns a read-only copy of the gauge.
func (g *GaugeFloat64) Snapshot() *GaugeFloat64 {
gg := NewGaugeFloat64(g.Metadata)
gg.value = atomic.LoadUint64(&g.value)
return gg
}
// ExportMetric returns a filled-in metric data of the right type for the given metric.
func (g *GaugeFloat64) ExportMetric() *metrics.MetricData {
return &metrics.MetricData{
Gauge: &metrics.GaugeData{Value: g.Value()},
Labels: g.Labels[:],
Unit: g.Unit,
TimestampNs: time.Now().UnixNano(),
}
}