162 lines
3.5 KiB
Go
162 lines
3.5 KiB
Go
package metric
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"path"
|
|
"sort"
|
|
"strings"
|
|
"sync/atomic"
|
|
|
|
"repositories.action2quare.com/ayo/gocommon/logger"
|
|
)
|
|
|
|
const metric_value_line_size = 19
|
|
|
|
type MetricDescription struct {
|
|
Key string
|
|
Type MetricType
|
|
Name string `json:",omitempty"`
|
|
Help string `json:",omitempty"`
|
|
ConstLabels map[string]string `json:",omitempty"`
|
|
}
|
|
|
|
type Exporter interface {
|
|
RegisterMetric(*MetricDescription)
|
|
UpdateMetric(string, float64)
|
|
Shutdown()
|
|
}
|
|
|
|
type MetricWriter interface {
|
|
Add(int64)
|
|
Set(int64)
|
|
}
|
|
|
|
type metric_empty struct{}
|
|
|
|
func (mw *metric_empty) Set(int64) {}
|
|
func (mw *metric_empty) Add(int64) {}
|
|
|
|
var MetricWriterNil = MetricWriter(&metric_empty{})
|
|
|
|
type metric_int64 struct {
|
|
valptr *int64
|
|
buff [metric_value_line_size]byte
|
|
}
|
|
|
|
func (mw *metric_int64) printOut() {
|
|
binary.LittleEndian.PutUint64(mw.buff[9:], math.Float64bits(float64(atomic.LoadInt64(mw.valptr))))
|
|
os.Stdout.Write(mw.buff[:])
|
|
}
|
|
|
|
func (mw *metric_int64) Set(newval int64) {
|
|
atomic.StoreInt64(mw.valptr, newval)
|
|
mw.printOut()
|
|
}
|
|
|
|
func (mw *metric_int64) Add(inc int64) {
|
|
atomic.AddInt64(mw.valptr, inc)
|
|
mw.printOut()
|
|
}
|
|
|
|
func NewMetric(mt MetricType, name string, help string, constLabels map[string]string) (writer MetricWriter) {
|
|
if !metricEnabled {
|
|
return MetricWriterNil
|
|
}
|
|
|
|
var disorder []struct {
|
|
k string
|
|
v string
|
|
}
|
|
for k, v := range constLabels {
|
|
disorder = append(disorder, struct {
|
|
k string
|
|
v string
|
|
}{k: strings.ToLower(k), v: strings.ToLower(v)})
|
|
}
|
|
|
|
sort.Slice(disorder, func(i, j int) bool {
|
|
return disorder[i].k < disorder[j].k
|
|
})
|
|
|
|
hash := md5.New()
|
|
hash.Write([]byte(strings.ToLower(name)))
|
|
for _, d := range disorder {
|
|
hash.Write([]byte(d.k))
|
|
hash.Write([]byte(d.v))
|
|
}
|
|
|
|
key := hex.EncodeToString(hash.Sum(nil))[:metric_key_size]
|
|
temp, _ := json.Marshal(MetricDescription{
|
|
Key: key,
|
|
Type: mt,
|
|
Name: name,
|
|
Help: help,
|
|
ConstLabels: constLabels,
|
|
})
|
|
|
|
impl := &metric_int64{
|
|
valptr: new(int64),
|
|
}
|
|
|
|
impl.buff[0] = METRIC_HEAD_INLINE
|
|
impl.buff[17] = METRIC_TAIL_INLINE
|
|
impl.buff[18] = '\n'
|
|
copy(impl.buff[1:], []byte(key))
|
|
|
|
output := append([]byte{METRIC_HEAD_INLINE}, temp...)
|
|
output = append(output, METRIC_TAIL_INLINE, '\n')
|
|
os.Stdout.Write(output)
|
|
|
|
// writer
|
|
|
|
return impl
|
|
}
|
|
|
|
func ReadMetricValue(line []byte) (string, float64) {
|
|
if len(line) < 16 {
|
|
return "", 0
|
|
}
|
|
|
|
key := string(line[0:8])
|
|
valbits := binary.LittleEndian.Uint64(line[8:])
|
|
val := math.Float64frombits(valbits)
|
|
|
|
return key, val
|
|
}
|
|
|
|
var metricEnabled = false
|
|
|
|
func init() {
|
|
if path.Base(os.Args[0]) == "houston" {
|
|
logger.Println("metrics are going to be generated for myself(houston)")
|
|
metricEnabled = true
|
|
return
|
|
}
|
|
|
|
ppid := os.Getppid()
|
|
if parent, _ := os.FindProcess(ppid); parent != nil {
|
|
filename := fmt.Sprintf(`/proc/%d/stat`, os.Getppid())
|
|
if fn, err := os.ReadFile(filename); err == nil {
|
|
stats := strings.SplitN(string(fn), " ", 3)
|
|
parentname := strings.Trim(stats[1], "()")
|
|
|
|
if path.Base(parentname) == "houston" {
|
|
logger.Println("metrics are going to be generated for houston")
|
|
metricEnabled = true
|
|
} else {
|
|
logger.Println("metrics are NOT going to be generated. parent is not houston :", filename, string(fn))
|
|
}
|
|
} else {
|
|
logger.Println("metrics are NOT going to be generated. ppid proc is missing :", filename)
|
|
}
|
|
} else {
|
|
logger.Println("metrics are NOT going to be generated. parent process is missing. ppid :", ppid)
|
|
}
|
|
}
|