mirror of
https://github.com/ClusterCockpit/cc-metric-collector.git
synced 2024-12-27 07:39:05 +01:00
377 lines
8.6 KiB
Go
377 lines
8.6 KiB
Go
package metricRouter
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
|
|
cclog "github.com/ClusterCockpit/cc-metric-collector/internal/ccLogger"
|
|
topo "github.com/ClusterCockpit/cc-metric-collector/internal/ccTopology"
|
|
)
|
|
|
|
/*
|
|
* Arithmetic functions on value arrays
|
|
*/
|
|
|
|
// Sum up values
|
|
func sumfunc(args ...interface{}) (interface{}, error) {
|
|
s := 0.0
|
|
values, ok := args[0].([]float64)
|
|
if ok {
|
|
cclog.ComponentDebug("MetricCache", "SUM FUNC START")
|
|
for _, x := range values {
|
|
s += x
|
|
}
|
|
cclog.ComponentDebug("MetricCache", "SUM FUNC END", s)
|
|
} else {
|
|
cclog.ComponentDebug("MetricCache", "SUM FUNC CAST FAILED")
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// Get the minimum value
|
|
func minfunc(args ...interface{}) (interface{}, error) {
|
|
var err error = nil
|
|
switch values := args[0].(type) {
|
|
case []float64:
|
|
var s float64 = math.MaxFloat64
|
|
for _, x := range values {
|
|
if x < s {
|
|
s = x
|
|
}
|
|
}
|
|
return s, nil
|
|
case []float32:
|
|
var s float32 = math.MaxFloat32
|
|
for _, x := range values {
|
|
if x < s {
|
|
s = x
|
|
}
|
|
}
|
|
return s, nil
|
|
case []int:
|
|
var s int = math.MaxInt
|
|
for _, x := range values {
|
|
if x < s {
|
|
s = x
|
|
}
|
|
}
|
|
return s, nil
|
|
case []int64:
|
|
var s int64 = math.MaxInt64
|
|
for _, x := range values {
|
|
if x < s {
|
|
s = x
|
|
}
|
|
}
|
|
return s, nil
|
|
case []int32:
|
|
var s int32 = math.MaxInt32
|
|
for _, x := range values {
|
|
if x < s {
|
|
s = x
|
|
}
|
|
}
|
|
return s, nil
|
|
default:
|
|
err = errors.New("function 'min' only on list of values (float64, float32, int, int32, int64)")
|
|
}
|
|
|
|
return 0.0, err
|
|
}
|
|
|
|
// Get the average or mean value
|
|
func avgfunc(args ...interface{}) (interface{}, error) {
|
|
switch values := args[0].(type) {
|
|
case []float64:
|
|
var s float64 = 0
|
|
for _, x := range values {
|
|
s += x
|
|
}
|
|
return s / float64(len(values)), nil
|
|
case []float32:
|
|
var s float32 = 0
|
|
for _, x := range values {
|
|
s += x
|
|
}
|
|
return s / float32(len(values)), nil
|
|
case []int:
|
|
var s int = 0
|
|
for _, x := range values {
|
|
s += x
|
|
}
|
|
return s / len(values), nil
|
|
case []int64:
|
|
var s int64 = 0
|
|
for _, x := range values {
|
|
s += x
|
|
}
|
|
return s / int64(len(values)), nil
|
|
}
|
|
return 0.0, nil
|
|
}
|
|
|
|
// Get the maximum value
|
|
func maxfunc(args ...interface{}) (interface{}, error) {
|
|
s := 0.0
|
|
values, ok := args[0].([]float64)
|
|
if ok {
|
|
for _, x := range values {
|
|
if x > s {
|
|
s = x
|
|
}
|
|
}
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// Get the median value
|
|
func medianfunc(args ...interface{}) (interface{}, error) {
|
|
switch values := args[0].(type) {
|
|
case []float64:
|
|
sort.Float64s(values)
|
|
return values[len(values)/2], nil
|
|
// case []float32:
|
|
// sort.Float64s(values)
|
|
// return values[len(values)/2], nil
|
|
case []int:
|
|
sort.Ints(values)
|
|
return values[len(values)/2], nil
|
|
|
|
// case []int64:
|
|
// sort.Ints(values)
|
|
// return values[len(values)/2], nil
|
|
// case []int32:
|
|
// sort.Ints(values)
|
|
// return values[len(values)/2], nil
|
|
}
|
|
return 0.0, errors.New("function 'median()' only on lists of type float64 and int")
|
|
}
|
|
|
|
/*
|
|
* Get number of values in list. Returns always an int
|
|
*/
|
|
|
|
func lenfunc(args ...interface{}) (interface{}, error) {
|
|
var err error = nil
|
|
var length int = 0
|
|
switch values := args[0].(type) {
|
|
case []float64:
|
|
length = len(values)
|
|
case []float32:
|
|
length = len(values)
|
|
case []int:
|
|
length = len(values)
|
|
case []int64:
|
|
length = len(values)
|
|
case []int32:
|
|
length = len(values)
|
|
case float64:
|
|
err = errors.New("function 'len' can only be applied on arrays and strings")
|
|
case float32:
|
|
err = errors.New("function 'len' can only be applied on arrays and strings")
|
|
case int:
|
|
err = errors.New("function 'len' can only be applied on arrays and strings")
|
|
case int64:
|
|
err = errors.New("function 'len' can only be applied on arrays and strings")
|
|
case string:
|
|
length = len(values)
|
|
}
|
|
return length, err
|
|
}
|
|
|
|
/*
|
|
* Check if a values is in a list
|
|
* In constrast to most of the other functions, this one is an infix operator for
|
|
* - substring matching: `"abc" in "abcdef"` -> true
|
|
* - substring matching with int casting: `3 in "abd3"` -> true
|
|
* - search for an int in an int list: `3 in getCpuList()` -> true (if you have more than 4 CPU hardware threads)
|
|
*/
|
|
|
|
func infunc(a interface{}, b interface{}) (interface{}, error) {
|
|
switch match := a.(type) {
|
|
case string:
|
|
switch total := b.(type) {
|
|
case string:
|
|
return strings.Contains(total, match), nil
|
|
}
|
|
case int:
|
|
switch total := b.(type) {
|
|
case []int:
|
|
for _, x := range total {
|
|
if x == match {
|
|
return true, nil
|
|
}
|
|
}
|
|
case string:
|
|
smatch := fmt.Sprintf("%d", match)
|
|
return strings.Contains(total, smatch), nil
|
|
}
|
|
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
/*
|
|
* Regex matching of strings (metric name, tag keys, tag values, meta keys, meta values)
|
|
* Since we cannot use \ inside JSON strings without escaping, we use % instead for the
|
|
* format keys \d = %d, \w = %d, ... Not sure how to fix this
|
|
*/
|
|
|
|
func matchfunc(args ...interface{}) (interface{}, error) {
|
|
switch match := args[0].(type) {
|
|
case string:
|
|
switch total := args[1].(type) {
|
|
case string:
|
|
smatch := strings.Replace(match, "%", "\\", -1)
|
|
regex, err := regexp.Compile(smatch)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
s := regex.Find([]byte(total))
|
|
return s != nil, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
/*
|
|
* System topology getter functions
|
|
*/
|
|
|
|
// for a given cpuid, it returns the core id
|
|
func getCpuCoreFunc(args ...interface{}) (interface{}, error) {
|
|
switch cpuid := args[0].(type) {
|
|
case int:
|
|
return topo.GetCpuCore(cpuid), nil
|
|
}
|
|
return -1, errors.New("function 'getCpuCore' accepts only an 'int' cpuid")
|
|
}
|
|
|
|
// for a given cpuid, it returns the socket id
|
|
func getCpuSocketFunc(args ...interface{}) (interface{}, error) {
|
|
switch cpuid := args[0].(type) {
|
|
case int:
|
|
return topo.GetCpuSocket(cpuid), nil
|
|
}
|
|
return -1, errors.New("function 'getCpuCore' accepts only an 'int' cpuid")
|
|
}
|
|
|
|
// for a given cpuid, it returns the id of the NUMA node
|
|
func getCpuNumaDomainFunc(args ...interface{}) (interface{}, error) {
|
|
switch cpuid := args[0].(type) {
|
|
case int:
|
|
return topo.GetCpuNumaDomain(cpuid), nil
|
|
}
|
|
return -1, errors.New("function 'getCpuNuma' accepts only an 'int' cpuid")
|
|
}
|
|
|
|
// for a given cpuid, it returns the id of the CPU die
|
|
func getCpuDieFunc(args ...interface{}) (interface{}, error) {
|
|
switch cpuid := args[0].(type) {
|
|
case int:
|
|
return topo.GetCpuDie(cpuid), nil
|
|
}
|
|
return -1, errors.New("function 'getCpuDie' accepts only an 'int' cpuid")
|
|
}
|
|
|
|
// for a given core id, it returns the list of cpuids
|
|
func getCpuListOfCoreFunc(args ...interface{}) (interface{}, error) {
|
|
cpulist := make([]int, 0)
|
|
switch in := args[0].(type) {
|
|
case int:
|
|
for _, c := range topo.CpuData() {
|
|
if c.Core == in {
|
|
cpulist = append(cpulist, c.Cpuid)
|
|
}
|
|
}
|
|
}
|
|
return cpulist, nil
|
|
}
|
|
|
|
// for a given socket id, it returns the list of cpuids
|
|
func getCpuListOfSocketFunc(args ...interface{}) (interface{}, error) {
|
|
cpulist := make([]int, 0)
|
|
switch in := args[0].(type) {
|
|
case int:
|
|
for _, c := range topo.CpuData() {
|
|
if c.Socket == in {
|
|
cpulist = append(cpulist, c.Cpuid)
|
|
}
|
|
}
|
|
}
|
|
return cpulist, nil
|
|
}
|
|
|
|
// for a given id of a NUMA domain, it returns the list of cpuids
|
|
func getCpuListOfNumaDomainFunc(args ...interface{}) (interface{}, error) {
|
|
cpulist := make([]int, 0)
|
|
switch in := args[0].(type) {
|
|
case int:
|
|
for _, c := range topo.CpuData() {
|
|
if c.Numadomain == in {
|
|
cpulist = append(cpulist, c.Cpuid)
|
|
}
|
|
}
|
|
}
|
|
return cpulist, nil
|
|
}
|
|
|
|
// for a given CPU die id, it returns the list of cpuids
|
|
func getCpuListOfDieFunc(args ...interface{}) (interface{}, error) {
|
|
cpulist := make([]int, 0)
|
|
switch in := args[0].(type) {
|
|
case int:
|
|
for _, c := range topo.CpuData() {
|
|
if c.Die == in {
|
|
cpulist = append(cpulist, c.Cpuid)
|
|
}
|
|
}
|
|
}
|
|
return cpulist, nil
|
|
}
|
|
|
|
// wrapper function to get a list of all cpuids of the node
|
|
func getCpuListOfNode(args ...interface{}) (interface{}, error) {
|
|
return topo.CpuList(), nil
|
|
}
|
|
|
|
// helper function to get the cpuid list for a CCMetric type tag set (type and type-id)
|
|
// since there is no access to the metric data in the function, is should be called like
|
|
// `getCpuListOfType()`
|
|
func getCpuListOfType(args ...interface{}) (interface{}, error) {
|
|
cpulist := make([]int, 0)
|
|
switch typ := args[0].(type) {
|
|
case string:
|
|
switch typ {
|
|
case "node":
|
|
return topo.CpuList(), nil
|
|
case "socket":
|
|
return getCpuListOfSocketFunc(args[1])
|
|
case "numadomain":
|
|
return getCpuListOfNumaDomainFunc(args[1])
|
|
case "core":
|
|
return getCpuListOfCoreFunc(args[1])
|
|
case "cpu":
|
|
var cpu int
|
|
|
|
switch id := args[1].(type) {
|
|
case string:
|
|
_, err := fmt.Scanf(id, "%d", &cpu)
|
|
if err == nil {
|
|
cpulist = append(cpulist, cpu)
|
|
}
|
|
case int:
|
|
cpulist = append(cpulist, id)
|
|
case int64:
|
|
cpulist = append(cpulist, int(id))
|
|
}
|
|
|
|
}
|
|
}
|
|
return cpulist, errors.New("no valid args type and type-id")
|
|
}
|