mirror of
https://github.com/prometheus-community/windows_exporter
synced 2024-12-30 18:32:07 +00:00
112 lines
2.8 KiB
Go
112 lines
2.8 KiB
Go
package perflib
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"github.com/go-kit/log"
|
|
"github.com/go-kit/log/level"
|
|
)
|
|
|
|
// Conversion factors
|
|
const (
|
|
TicksToSecondScaleFactor = 1 / 1e7
|
|
WindowsEpoch = 116444736000000000
|
|
)
|
|
|
|
func UnmarshalObject(obj *PerfObject, vs interface{}, logger log.Logger) error {
|
|
if obj == nil {
|
|
return fmt.Errorf("counter not found")
|
|
}
|
|
rv := reflect.ValueOf(vs)
|
|
if rv.Kind() != reflect.Ptr || rv.IsNil() {
|
|
return fmt.Errorf("%v is nil or not a pointer to slice", reflect.TypeOf(vs))
|
|
}
|
|
ev := rv.Elem()
|
|
if ev.Kind() != reflect.Slice {
|
|
return fmt.Errorf("%v is not slice", reflect.TypeOf(vs))
|
|
}
|
|
|
|
// Ensure sufficient length
|
|
if ev.Cap() < len(obj.Instances) {
|
|
nvs := reflect.MakeSlice(ev.Type(), len(obj.Instances), len(obj.Instances))
|
|
ev.Set(nvs)
|
|
}
|
|
|
|
for idx, instance := range obj.Instances {
|
|
target := ev.Index(idx)
|
|
rt := target.Type()
|
|
|
|
counters := make(map[string]*PerfCounter, len(instance.Counters))
|
|
for _, ctr := range instance.Counters {
|
|
if ctr.Def.IsBaseValue && !ctr.Def.IsNanosecondCounter {
|
|
counters[ctr.Def.Name+"_Base"] = ctr
|
|
} else {
|
|
counters[ctr.Def.Name] = ctr
|
|
}
|
|
}
|
|
|
|
for i := 0; i < target.NumField(); i++ {
|
|
f := rt.Field(i)
|
|
tag := f.Tag.Get("perflib")
|
|
if tag == "" {
|
|
continue
|
|
}
|
|
secondValue := false
|
|
|
|
st := strings.Split(tag, ",")
|
|
tag = st[0]
|
|
|
|
for _, t := range st {
|
|
if t == "secondvalue" {
|
|
secondValue = true
|
|
}
|
|
}
|
|
|
|
ctr, found := counters[tag]
|
|
if !found {
|
|
_ = level.Debug(logger).Log("msg", fmt.Sprintf("missing counter %q, have %v", tag, counterMapKeys(counters)))
|
|
continue
|
|
}
|
|
if !target.Field(i).CanSet() {
|
|
return fmt.Errorf("tagged field %v cannot be written to", f.Name)
|
|
}
|
|
if fieldType := target.Field(i).Type(); fieldType != reflect.TypeOf((*float64)(nil)).Elem() {
|
|
return fmt.Errorf("tagged field %v has wrong type %v, must be float64", f.Name, fieldType)
|
|
}
|
|
|
|
if secondValue {
|
|
if !ctr.Def.HasSecondValue {
|
|
return fmt.Errorf("tagged field %v expected a SecondValue, which was not present", f.Name)
|
|
}
|
|
target.Field(i).SetFloat(float64(ctr.SecondValue))
|
|
continue
|
|
}
|
|
|
|
switch ctr.Def.CounterType {
|
|
case PERF_ELAPSED_TIME:
|
|
target.Field(i).SetFloat(float64(ctr.Value-WindowsEpoch) / float64(obj.Frequency))
|
|
case PERF_100NSEC_TIMER, PERF_PRECISION_100NS_TIMER:
|
|
target.Field(i).SetFloat(float64(ctr.Value) * TicksToSecondScaleFactor)
|
|
default:
|
|
target.Field(i).SetFloat(float64(ctr.Value))
|
|
}
|
|
}
|
|
|
|
if instance.Name != "" && target.FieldByName("Name").CanSet() {
|
|
target.FieldByName("Name").SetString(instance.Name)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func counterMapKeys(m map[string]*PerfCounter) []string {
|
|
keys := make([]string, 0, len(m))
|
|
for k := range m {
|
|
keys = append(keys, k)
|
|
}
|
|
return keys
|
|
}
|