cc-backend/internal/metricdata/cc-metric-store.go

616 lines
17 KiB
Go
Raw Normal View History

2021-11-26 10:32:36 +01:00
package metricdata
import (
"bufio"
2021-11-26 10:32:36 +01:00
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
2022-05-04 09:22:55 +02:00
"strconv"
"strings"
2021-11-26 10:32:36 +01:00
"time"
2022-06-21 17:52:36 +02:00
"github.com/ClusterCockpit/cc-backend/internal/config"
"github.com/ClusterCockpit/cc-backend/pkg/schema"
2021-11-26 10:32:36 +01:00
)
type CCMetricStoreConfig struct {
Kind string `json:"kind"`
Url string `json:"url"`
Token string `json:"token"`
// If metrics are known to this MetricDataRepository under a different
// name than in the `metricConfig` section of the 'cluster.json',
// provide this optional mapping of local to remote name for this metric.
Renamings map[string]string `json:"metricRenamings"`
}
2021-11-26 10:32:36 +01:00
type CCMetricStore struct {
2022-01-20 10:43:46 +01:00
jwt string
url string
queryEndpoint string
client http.Client
2022-01-24 10:06:25 +01:00
here2there map[string]string
there2here map[string]string
2021-11-26 10:32:36 +01:00
}
2022-01-20 10:43:46 +01:00
type ApiQueryRequest struct {
Cluster string `json:"cluster"`
From int64 `json:"from"`
To int64 `json:"to"`
WithStats bool `json:"with-stats"`
WithData bool `json:"with-data"`
Queries []ApiQuery `json:"queries"`
ForAllNodes []string `json:"for-all-nodes"`
2021-11-26 10:32:36 +01:00
}
2022-01-12 13:03:01 +01:00
type ApiQuery struct {
2022-05-04 09:22:55 +02:00
Metric string `json:"metric"`
Hostname string `json:"host"`
Aggregate bool `json:"aggreg"`
Type *string `json:"type,omitempty"`
TypeIds []string `json:"type-ids,omitempty"`
SubType *string `json:"subtype,omitempty"`
SubTypeIds []string `json:"subtype-ids,omitempty"`
2022-01-12 13:03:01 +01:00
}
type ApiQueryResponse struct {
Queries []ApiQuery `json:"queries,omitempty"`
Results [][]ApiMetricData `json:"results"`
}
2021-11-26 10:32:36 +01:00
type ApiMetricData struct {
Error *string `json:"error"`
From int64 `json:"from"`
To int64 `json:"to"`
Data []schema.Float `json:"data"`
Avg schema.Float `json:"avg"`
Min schema.Float `json:"min"`
Max schema.Float `json:"max"`
2021-11-26 10:32:36 +01:00
}
func (ccms *CCMetricStore) Init(rawConfig json.RawMessage) error {
var config CCMetricStoreConfig
if err := json.Unmarshal(rawConfig, &config); err != nil {
return err
}
ccms.url = config.Url
ccms.queryEndpoint = fmt.Sprintf("%s/api/query", config.Url)
ccms.jwt = config.Token
2022-01-12 13:03:01 +01:00
ccms.client = http.Client{
2022-03-29 15:22:17 +02:00
Timeout: 10 * time.Second,
2022-01-12 13:03:01 +01:00
}
2022-01-24 10:06:25 +01:00
if config.Renamings != nil {
ccms.here2there = config.Renamings
ccms.there2here = make(map[string]string, len(config.Renamings))
2022-01-24 10:06:25 +01:00
for k, v := range ccms.here2there {
ccms.there2here[v] = k
}
} else {
ccms.here2there = make(map[string]string)
ccms.there2here = make(map[string]string)
}
2021-11-26 10:32:36 +01:00
return nil
}
2022-01-24 10:06:25 +01:00
func (ccms *CCMetricStore) toRemoteName(metric string) string {
if renamed, ok := ccms.here2there[metric]; ok {
return renamed
}
return metric
}
func (ccms *CCMetricStore) toLocalName(metric string) string {
if renamed, ok := ccms.there2here[metric]; ok {
return renamed
}
return metric
}
func (ccms *CCMetricStore) doRequest(ctx context.Context, body *ApiQueryRequest) (*ApiQueryResponse, error) {
2022-01-20 10:43:46 +01:00
buf := &bytes.Buffer{}
if err := json.NewEncoder(buf).Encode(body); err != nil {
2021-11-26 10:32:36 +01:00
return nil, err
}
2022-01-20 10:43:46 +01:00
req, err := http.NewRequestWithContext(ctx, http.MethodPost, ccms.queryEndpoint, buf)
2021-11-26 10:32:36 +01:00
if err != nil {
return nil, err
}
2021-12-09 16:26:59 +01:00
if ccms.jwt != "" {
req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", ccms.jwt))
}
2021-11-26 10:32:36 +01:00
2022-01-20 10:43:46 +01:00
res, err := ccms.client.Do(req)
2022-01-12 13:03:01 +01:00
if err != nil {
return nil, err
}
2022-01-20 10:43:46 +01:00
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("'%s': HTTP Status: %s", ccms.queryEndpoint, res.Status)
}
var resBody ApiQueryResponse
2022-01-20 10:43:46 +01:00
if err := json.NewDecoder(bufio.NewReader(res.Body)).Decode(&resBody); err != nil {
return nil, err
}
return &resBody, nil
2022-01-20 10:43:46 +01:00
}
func (ccms *CCMetricStore) LoadData(job *schema.Job, metrics []string, scopes []schema.MetricScope, ctx context.Context) (schema.JobData, error) {
2022-05-04 09:22:55 +02:00
topology := config.GetSubCluster(job.Cluster, job.SubCluster).Topology
2022-01-20 10:43:46 +01:00
queries, assignedScope, err := ccms.buildQueries(job, metrics, scopes)
if err != nil {
return nil, err
}
2022-01-20 10:43:46 +01:00
req := ApiQueryRequest{
Cluster: job.Cluster,
From: job.StartTime.Unix(),
To: job.StartTime.Add(time.Duration(job.Duration) * time.Second).Unix(),
Queries: queries,
WithStats: true,
WithData: true,
}
2022-01-20 10:43:46 +01:00
resBody, err := ccms.doRequest(ctx, &req)
if err != nil {
return nil, err
}
var errors []string
var jobData schema.JobData = make(schema.JobData)
for i, row := range resBody.Results {
2022-01-20 10:43:46 +01:00
query := req.Queries[i]
2022-01-24 10:06:25 +01:00
metric := ccms.toLocalName(query.Metric)
2022-01-20 10:43:46 +01:00
scope := assignedScope[i]
2022-01-24 10:06:25 +01:00
mc := config.GetMetricConfig(job.Cluster, metric)
if _, ok := jobData[metric]; !ok {
jobData[metric] = make(map[schema.MetricScope]*schema.JobMetric)
}
2022-01-24 10:06:25 +01:00
jobMetric, ok := jobData[metric][scope]
if !ok {
jobMetric = &schema.JobMetric{
Unit: mc.Unit,
Scope: scope,
Timestep: mc.Timestep,
Series: make([]schema.Series, 0),
}
2022-01-24 10:06:25 +01:00
jobData[metric][scope] = jobMetric
}
2022-01-20 10:43:46 +01:00
for _, res := range row {
if res.Error != nil {
errors = append(errors, fmt.Sprintf("failed to fetch '%s' from host '%s': %s", query.Metric, query.Hostname, *res.Error))
continue
2022-01-20 10:43:46 +01:00
}
2022-01-20 10:43:46 +01:00
id := (*int)(nil)
if query.Type != nil {
id = new(int)
2022-05-04 09:22:55 +02:00
*id, err = strconv.Atoi(query.TypeIds[0])
if err != nil || *query.Type == acceleratorString {
*id, _ = topology.GetAcceleratorIndex(query.TypeIds[0])
}
2022-01-20 10:43:46 +01:00
}
if res.Avg.IsNaN() || res.Min.IsNaN() || res.Max.IsNaN() {
// TODO: use schema.Float instead of float64?
// This is done because regular float64 can not be JSONed when NaN.
res.Avg = schema.Float(0)
res.Min = schema.Float(0)
res.Max = schema.Float(0)
}
2022-01-20 10:43:46 +01:00
jobMetric.Series = append(jobMetric.Series, schema.Series{
Hostname: query.Hostname,
Id: id,
Statistics: &schema.MetricStatistics{
Avg: float64(res.Avg),
Min: float64(res.Min),
Max: float64(res.Max),
},
Data: res.Data,
})
}
// So that one can later check len(jobData):
if len(jobMetric.Series) == 0 {
delete(jobData[metric], scope)
if len(jobData[metric]) == 0 {
delete(jobData, metric)
}
}
2021-11-26 10:32:36 +01:00
}
if len(errors) != 0 {
return jobData, fmt.Errorf("cc-metric-store: %s", strings.Join(errors, ", "))
}
2021-11-26 10:32:36 +01:00
return jobData, nil
}
2022-01-12 13:03:01 +01:00
var (
hwthreadString = string(schema.MetricScopeHWThread)
coreString = string(schema.MetricScopeCore)
memoryDomainString = string(schema.MetricScopeMemoryDomain)
socketString = string(schema.MetricScopeSocket)
acceleratorString = string(schema.MetricScopeAccelerator)
2022-01-12 13:03:01 +01:00
)
func (ccms *CCMetricStore) buildQueries(job *schema.Job, metrics []string, scopes []schema.MetricScope) ([]ApiQuery, []schema.MetricScope, error) {
2022-01-12 13:03:01 +01:00
queries := make([]ApiQuery, 0, len(metrics)*len(scopes)*len(job.Resources))
topology := config.GetSubCluster(job.Cluster, job.SubCluster).Topology
assignedScope := []schema.MetricScope{}
2022-01-12 13:03:01 +01:00
for _, metric := range metrics {
2022-01-24 10:06:25 +01:00
remoteName := ccms.toRemoteName(metric)
2022-01-12 13:03:01 +01:00
mc := config.GetMetricConfig(job.Cluster, metric)
if mc == nil {
// return nil, fmt.Errorf("metric '%s' is not specified for cluster '%s'", metric, job.Cluster)
// log.Printf("metric '%s' is not specified for cluster '%s'", metric, job.Cluster)
continue
}
// Avoid duplicates...
handledScopes := make([]schema.MetricScope, 0, 3)
2022-01-12 13:03:01 +01:00
scopesLoop:
for _, requestedScope := range scopes {
nativeScope := mc.Scope
if nativeScope == schema.MetricScopeAccelerator && job.NumAcc == 0 {
continue
}
scope := nativeScope.Max(requestedScope)
for _, s := range handledScopes {
if scope == s {
continue scopesLoop
}
2022-01-12 13:03:01 +01:00
}
handledScopes = append(handledScopes, scope)
2022-01-12 13:03:01 +01:00
for _, host := range job.Resources {
hwthreads := host.HWThreads
if hwthreads == nil {
hwthreads = topology.Node
}
2022-01-12 13:03:01 +01:00
// Accelerator -> Accelerator (Use "accelerator" scope if requested scope is lower than node)
if nativeScope == schema.MetricScopeAccelerator && scope.LT(schema.MetricScopeNode) {
2022-01-20 10:43:46 +01:00
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: false,
Type: &acceleratorString,
TypeIds: host.Accelerators,
})
assignedScope = append(assignedScope, schema.MetricScopeAccelerator)
continue
}
2022-01-12 13:03:01 +01:00
// Accelerator -> Node
if nativeScope == schema.MetricScopeAccelerator && scope == schema.MetricScopeNode {
if len(host.Accelerators) == 0 {
continue
}
2022-01-12 13:03:01 +01:00
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: true,
Type: &acceleratorString,
TypeIds: host.Accelerators,
})
2022-01-20 10:43:46 +01:00
assignedScope = append(assignedScope, scope)
continue
}
2022-01-12 13:03:01 +01:00
// HWThread -> HWThead
if nativeScope == schema.MetricScopeHWThread && scope == schema.MetricScopeHWThread {
2022-01-20 10:43:46 +01:00
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: false,
Type: &hwthreadString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(hwthreads),
2022-01-20 10:43:46 +01:00
})
assignedScope = append(assignedScope, scope)
continue
}
2022-01-12 13:03:01 +01:00
// HWThread -> Core
if nativeScope == schema.MetricScopeHWThread && scope == schema.MetricScopeCore {
cores, _ := topology.GetCoresFromHWThreads(hwthreads)
for _, core := range cores {
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: true,
Type: &hwthreadString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(topology.Core[core]),
})
2022-01-20 10:43:46 +01:00
assignedScope = append(assignedScope, scope)
}
continue
}
2022-01-12 13:03:01 +01:00
// HWThread -> Socket
if nativeScope == schema.MetricScopeHWThread && scope == schema.MetricScopeSocket {
sockets, _ := topology.GetSocketsFromHWThreads(hwthreads)
for _, socket := range sockets {
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: true,
Type: &hwthreadString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(topology.Socket[socket]),
})
2022-01-20 10:43:46 +01:00
assignedScope = append(assignedScope, scope)
}
continue
}
2022-01-12 13:03:01 +01:00
// HWThread -> Node
if nativeScope == schema.MetricScopeHWThread && scope == schema.MetricScopeNode {
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: true,
Type: &hwthreadString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(hwthreads),
2022-01-20 10:43:46 +01:00
})
assignedScope = append(assignedScope, scope)
continue
}
// Core -> Core
if nativeScope == schema.MetricScopeCore && scope == schema.MetricScopeCore {
cores, _ := topology.GetCoresFromHWThreads(hwthreads)
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: false,
Type: &coreString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(cores),
2022-01-20 10:43:46 +01:00
})
assignedScope = append(assignedScope, scope)
continue
}
// Core -> Node
if nativeScope == schema.MetricScopeCore && scope == schema.MetricScopeNode {
cores, _ := topology.GetCoresFromHWThreads(hwthreads)
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: true,
Type: &coreString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(cores),
})
2022-01-20 10:43:46 +01:00
assignedScope = append(assignedScope, scope)
continue
}
2022-01-12 13:03:01 +01:00
// MemoryDomain -> MemoryDomain
if nativeScope == schema.MetricScopeMemoryDomain && scope == schema.MetricScopeMemoryDomain {
sockets, _ := topology.GetMemoryDomainsFromHWThreads(hwthreads)
queries = append(queries, ApiQuery{
Metric: remoteName,
Hostname: host.Hostname,
Aggregate: false,
Type: &memoryDomainString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(sockets),
})
assignedScope = append(assignedScope, scope)
continue
}
// MemoryDoman -> Node
if nativeScope == schema.MetricScopeMemoryDomain && scope == schema.MetricScopeNode {
sockets, _ := topology.GetMemoryDomainsFromHWThreads(hwthreads)
queries = append(queries, ApiQuery{
Metric: remoteName,
Hostname: host.Hostname,
Aggregate: true,
Type: &memoryDomainString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(sockets),
})
assignedScope = append(assignedScope, scope)
continue
}
// Socket -> Socket
if nativeScope == schema.MetricScopeSocket && scope == schema.MetricScopeSocket {
sockets, _ := topology.GetSocketsFromHWThreads(hwthreads)
2022-01-20 10:43:46 +01:00
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: false,
Type: &socketString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(sockets),
2022-01-20 10:43:46 +01:00
})
assignedScope = append(assignedScope, scope)
continue
}
2022-01-12 13:03:01 +01:00
// Socket -> Node
if nativeScope == schema.MetricScopeSocket && scope == schema.MetricScopeNode {
sockets, _ := topology.GetSocketsFromHWThreads(hwthreads)
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
2022-01-20 10:43:46 +01:00
Hostname: host.Hostname,
Aggregate: true,
Type: &socketString,
2022-05-04 09:22:55 +02:00
TypeIds: intToStringSlice(sockets),
})
2022-01-20 10:43:46 +01:00
assignedScope = append(assignedScope, scope)
continue
}
2022-01-12 13:03:01 +01:00
// Node -> Node
if nativeScope == schema.MetricScopeNode && scope == schema.MetricScopeNode {
2022-01-12 13:03:01 +01:00
queries = append(queries, ApiQuery{
2022-01-24 10:06:25 +01:00
Metric: remoteName,
Hostname: host.Hostname,
2022-01-12 13:03:01 +01:00
})
2022-01-20 10:43:46 +01:00
assignedScope = append(assignedScope, scope)
continue
2022-01-12 13:03:01 +01:00
}
return nil, nil, fmt.Errorf("TODO: unhandled case: native-scope=%s, requested-scope=%s", nativeScope, requestedScope)
2022-01-12 13:03:01 +01:00
}
}
}
return queries, assignedScope, nil
}
2021-12-17 15:49:22 +01:00
func (ccms *CCMetricStore) LoadStats(job *schema.Job, metrics []string, ctx context.Context) (map[string]map[string]schema.MetricStatistics, error) {
2022-01-20 10:43:46 +01:00
queries, _, err := ccms.buildQueries(job, metrics, []schema.MetricScope{schema.MetricScopeNode})
if err != nil {
return nil, err
}
2022-01-20 10:43:46 +01:00
req := ApiQueryRequest{
Cluster: job.Cluster,
From: job.StartTime.Unix(),
To: job.StartTime.Add(time.Duration(job.Duration) * time.Second).Unix(),
Queries: queries,
WithStats: true,
WithData: false,
}
2022-01-20 10:43:46 +01:00
resBody, err := ccms.doRequest(ctx, &req)
if err != nil {
return nil, err
}
2022-01-20 10:43:46 +01:00
stats := make(map[string]map[string]schema.MetricStatistics, len(metrics))
for i, res := range resBody.Results {
2022-01-20 10:43:46 +01:00
query := req.Queries[i]
2022-01-24 10:06:25 +01:00
metric := ccms.toLocalName(query.Metric)
2022-01-20 10:43:46 +01:00
data := res[0]
if data.Error != nil {
2022-01-24 10:06:25 +01:00
return nil, fmt.Errorf("fetching %s for node %s failed: %s", metric, query.Hostname, *data.Error)
2022-01-20 10:43:46 +01:00
}
2022-01-24 10:06:25 +01:00
metricdata, ok := stats[metric]
2022-01-20 10:43:46 +01:00
if !ok {
metricdata = make(map[string]schema.MetricStatistics, job.NumNodes)
2022-01-24 10:06:25 +01:00
stats[metric] = metricdata
2022-01-20 10:43:46 +01:00
}
2022-01-20 10:43:46 +01:00
if data.Avg.IsNaN() || data.Min.IsNaN() || data.Max.IsNaN() {
2022-01-24 10:06:25 +01:00
return nil, fmt.Errorf("fetching %s for node %s failed: %s", metric, query.Hostname, "avg/min/max is NaN")
}
2022-01-20 10:43:46 +01:00
metricdata[query.Hostname] = schema.MetricStatistics{
Avg: float64(data.Avg),
Min: float64(data.Min),
Max: float64(data.Max),
}
}
return stats, nil
}
// TODO: Support sub-node-scope metrics! For this, the partition of a node needs to be known!
func (ccms *CCMetricStore) LoadNodeData(cluster string, metrics, nodes []string, scopes []schema.MetricScope, from, to time.Time, ctx context.Context) (map[string]map[string][]*schema.JobMetric, error) {
2022-01-20 10:43:46 +01:00
req := ApiQueryRequest{
Cluster: cluster,
From: from.Unix(),
To: to.Unix(),
WithStats: true,
2022-01-20 10:43:46 +01:00
WithData: true,
}
if nodes == nil {
for _, metric := range metrics {
req.ForAllNodes = append(req.ForAllNodes, ccms.toRemoteName(metric))
}
} else {
2022-01-20 10:43:46 +01:00
for _, node := range nodes {
for _, metric := range metrics {
req.Queries = append(req.Queries, ApiQuery{
Hostname: node,
2022-01-24 10:06:25 +01:00
Metric: ccms.toRemoteName(metric),
2022-01-20 10:43:46 +01:00
})
}
}
2021-12-09 16:26:59 +01:00
}
2022-01-20 10:43:46 +01:00
resBody, err := ccms.doRequest(ctx, &req)
if err != nil {
return nil, err
}
var errors []string
data := make(map[string]map[string][]*schema.JobMetric)
for i, res := range resBody.Results {
var query ApiQuery
if resBody.Queries != nil {
query = resBody.Queries[i]
} else {
query = req.Queries[i]
}
metric := ccms.toLocalName(query.Metric)
2022-01-20 10:43:46 +01:00
qdata := res[0]
if qdata.Error != nil {
errors = append(errors, fmt.Sprintf("fetching %s for node %s failed: %s", metric, query.Hostname, *qdata.Error))
}
if qdata.Avg.IsNaN() || qdata.Min.IsNaN() || qdata.Max.IsNaN() {
// return nil, fmt.Errorf("fetching %s for node %s failed: %s", metric, query.Hostname, "avg/min/max is NaN")
qdata.Avg, qdata.Min, qdata.Max = 0., 0., 0.
}
hostdata, ok := data[query.Hostname]
2022-01-20 10:43:46 +01:00
if !ok {
hostdata = make(map[string][]*schema.JobMetric)
data[query.Hostname] = hostdata
}
mc := config.GetMetricConfig(cluster, metric)
2022-02-08 11:03:32 +01:00
hostdata[metric] = append(hostdata[metric], &schema.JobMetric{
Unit: mc.Unit,
Scope: schema.MetricScopeNode,
Timestep: mc.Timestep,
Series: []schema.Series{
{
Hostname: query.Hostname,
Data: qdata.Data,
Statistics: &schema.MetricStatistics{
Avg: float64(qdata.Avg),
Min: float64(qdata.Min),
Max: float64(qdata.Max),
},
},
},
})
}
if len(errors) != 0 {
return data, fmt.Errorf("cc-metric-store: %s", strings.Join(errors, ", "))
}
return data, nil
}
2022-05-04 09:22:55 +02:00
func intToStringSlice(is []int) []string {
2022-05-05 10:03:54 +02:00
ss := make([]string, len(is))
2022-05-04 09:22:55 +02:00
for i, x := range is {
ss[i] = strconv.Itoa(x)
}
return ss
}