Replace explicit resampling config with policy based approach

Entire-Checkpoint: f69e38210bb1

internal/graph/resample.go

@@ -0,0 +1,113 @@
+// Copyright (C) NHR@FAU, University Erlangen-Nuremberg.
+// All rights reserved. This file is part of cc-backend.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+package graph
+
+import (
+	"context"
+	"strings"
+
+	"github.com/ClusterCockpit/cc-backend/internal/graph/model"
+	"github.com/ClusterCockpit/cc-backend/internal/metricdispatch"
+	"github.com/ClusterCockpit/cc-backend/internal/repository"
+	"github.com/ClusterCockpit/cc-backend/pkg/archive"
+)
+
+// resolveResolutionFromPolicy reads the user's resample policy preference and
+// computes a resolution based on job duration and metric frequency. Returns nil
+// if the user has no policy set.
+func resolveResolutionFromPolicy(ctx context.Context, duration int64, cluster string, metrics []string) *int {
+	user := repository.GetUserFromContext(ctx)
+	if user == nil {
+		return nil
+	}
+
+	conf, err := repository.GetUserCfgRepo().GetUIConfig(user)
+	if err != nil {
+		return nil
+	}
+
+	policyVal, ok := conf["plotConfiguration_resamplePolicy"]
+	if !ok {
+		return nil
+	}
+	policyStr, ok := policyVal.(string)
+	if !ok || policyStr == "" {
+		return nil
+	}
+
+	policy := metricdispatch.ResamplePolicy(policyStr)
+	targetPoints := metricdispatch.TargetPointsForPolicy(policy)
+	if targetPoints == 0 {
+		return nil
+	}
+
+	// Find the smallest metric frequency across the requested metrics
+	frequency := smallestFrequency(cluster, metrics)
+	if frequency <= 0 {
+		return nil
+	}
+
+	res := metricdispatch.ComputeResolution(duration, int64(frequency), targetPoints)
+	return &res
+}
+
+// resolveResampleAlgo returns the resampling algorithm name to use, checking
+// the explicit GraphQL parameter first, then the user's preference.
+func resolveResampleAlgo(ctx context.Context, resampleAlgo *model.ResampleAlgo) string {
+	if resampleAlgo != nil {
+		return strings.ToLower(resampleAlgo.String())
+	}
+
+	user := repository.GetUserFromContext(ctx)
+	if user == nil {
+		return ""
+	}
+
+	conf, err := repository.GetUserCfgRepo().GetUIConfig(user)
+	if err != nil {
+		return ""
+	}
+
+	algoVal, ok := conf["plotConfiguration_resampleAlgo"]
+	if !ok {
+		return ""
+	}
+	algoStr, ok := algoVal.(string)
+	if !ok {
+		return ""
+	}
+
+	return algoStr
+}
+
+// smallestFrequency returns the smallest metric timestep (in seconds) among the
+// requested metrics for the given cluster. Falls back to 0 if nothing is found.
+func smallestFrequency(cluster string, metrics []string) int {
+	cl := archive.GetCluster(cluster)
+	if cl == nil {
+		return 0
+	}
+
+	minFreq := 0
+	for _, mc := range cl.MetricConfig {
+		if len(metrics) > 0 {
+			found := false
+			for _, m := range metrics {
+				if mc.Name == m {
+					found = true
+					break
+				}
+			}
+			if !found {
+				continue
+			}
+		}
+		if minFreq == 0 || mc.Timestep < minFreq {
+			minFreq = mc.Timestep
+		}
+	}
+
+	return minFreq
+}

internal/graph/schema.resolvers.go

@@ -499,26 +499,27 @@ func (r *queryResolver) Job(ctx context.Context, id string) (*schema.Job, error)
 
 // JobMetrics is the resolver for the jobMetrics field.
 func (r *queryResolver) JobMetrics(ctx context.Context, id string, metrics []string, scopes []schema.MetricScope, resolution *int, resampleAlgo *model.ResampleAlgo) ([]*model.JobMetricWithName, error) {
-	if resolution == nil { // Load from Config
-		if config.Keys.EnableResampling != nil {
-			defaultRes := slices.Max(config.Keys.EnableResampling.Resolutions)
-			resolution = &defaultRes
-		} else { // Set 0 (Loads configured metric timestep)
-			defaultRes := 0
-			resolution = &defaultRes
-		}
-	}
-
 	job, err := r.Query().Job(ctx, id)
 	if err != nil {
 		cclog.Warn("Error while querying job for metrics")
 		return nil, err
 	}
 
-	algoName := ""
-	if resampleAlgo != nil {
-		algoName = strings.ToLower(resampleAlgo.String())
+	// Resolve resolution: explicit param > user policy > global config > 0
+	if resolution == nil {
+		resolution = resolveResolutionFromPolicy(ctx, int64(job.Duration), job.Cluster, metrics)
 	}
+	if resolution == nil {
+		if config.Keys.EnableResampling != nil {
+			defaultRes := slices.Max(config.Keys.EnableResampling.Resolutions)
+			resolution = &defaultRes
+		} else {
+			defaultRes := 0
+			resolution = &defaultRes
+		}
+	}
+
+	algoName := resolveResampleAlgo(ctx, resampleAlgo)
 
 	data, err := metricdispatch.LoadData(job, metrics, scopes, ctx, *resolution, algoName)
 	if err != nil {
@@ -878,11 +879,16 @@ func (r *queryResolver) NodeMetrics(ctx context.Context, cluster string, nodes [
 
 // NodeMetricsList is the resolver for the nodeMetricsList field.
 func (r *queryResolver) NodeMetricsList(ctx context.Context, cluster string, subCluster string, stateFilter string, nodeFilter string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time, page *model.PageRequest, resolution *int, resampleAlgo *model.ResampleAlgo) (*model.NodesResultList, error) {
-	if resolution == nil { // Load from Config
+	// Resolve resolution: explicit param > user policy > global config > 0
+	duration := int64(to.Sub(from).Seconds())
+	if resolution == nil {
+		resolution = resolveResolutionFromPolicy(ctx, duration, cluster, metrics)
+	}
+	if resolution == nil {
 		if config.Keys.EnableResampling != nil {
 			defaultRes := slices.Max(config.Keys.EnableResampling.Resolutions)
 			resolution = &defaultRes
-		} else { // Set 0 (Loads configured metric timestep)
+		} else {
 			defaultRes := 0
 			resolution = &defaultRes
 		}
@@ -906,10 +912,7 @@ func (r *queryResolver) NodeMetricsList(ctx context.Context, cluster string, sub
 		}
 	}
 
-	algoName := ""
-	if resampleAlgo != nil {
-		algoName = strings.ToLower(resampleAlgo.String())
-	}
+	algoName := resolveResampleAlgo(ctx, resampleAlgo)
 
 	// data -> map hostname:jobdata
 	data, err := metricdispatch.LoadNodeListData(cluster, subCluster, nodes, metrics, scopes, *resolution, from, to, ctx, algoName)