This commit is contained in:
ITWorx Pulse release export
@@ -0,0 +1,256 @@
|
||||
package queryplan
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"math"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/itworx/pulse/internal/auth"
|
||||
"github.com/itworx/pulse/internal/metriccatalog"
|
||||
)
|
||||
|
||||
var scopeValuePattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$`)
|
||||
var scopeAliases = map[string]string{
|
||||
"entityId": "entity_id",
|
||||
"serverId": "instance",
|
||||
"containerId": "container",
|
||||
"diskId": "device",
|
||||
"poolId": "pool",
|
||||
"serviceId": "service_id",
|
||||
"probeId": "probe_id",
|
||||
}
|
||||
var allowedAggregations = map[string]struct{}{"none": {}, "avg": {}, "sum": {}, "min": {}, "max": {}, "rate": {}, "increase": {}, "p50": {}, "p95": {}, "p99": {}}
|
||||
|
||||
const (
|
||||
defaultMaxSeries = 20
|
||||
defaultMaxPoints = 4000
|
||||
maxGroupBy = 30
|
||||
maxScope = 20
|
||||
maxCostPoints = int64(10_000_000)
|
||||
)
|
||||
|
||||
type Range struct {
|
||||
From time.Time `json:"from"`
|
||||
To time.Time `json:"to"`
|
||||
StepSeconds int `json:"stepSeconds"`
|
||||
}
|
||||
|
||||
type Request struct {
|
||||
Metric string `json:"metric"`
|
||||
Scope map[string]string `json:"scope,omitempty"`
|
||||
Range Range `json:"range"`
|
||||
Aggregation string `json:"aggregation,omitempty"`
|
||||
GroupBy []string `json:"groupBy,omitempty"`
|
||||
MaxSeries int `json:"maxSeries,omitempty"`
|
||||
MaxPoints int `json:"maxPoints,omitempty"`
|
||||
}
|
||||
|
||||
type Limits struct {
|
||||
MaxSeries int
|
||||
MaxPoints int
|
||||
MaxCostPoints int64
|
||||
}
|
||||
|
||||
type Cost struct {
|
||||
Series int `json:"series"`
|
||||
Points int `json:"points"`
|
||||
EstimatedSamples int64 `json:"estimatedSamples"`
|
||||
}
|
||||
|
||||
type Plan struct {
|
||||
Metric metriccatalog.Definition `json:"metric"`
|
||||
Request Request `json:"request"`
|
||||
ResolvedScope map[string]string `json:"resolvedScope,omitempty"`
|
||||
Cost Cost `json:"cost"`
|
||||
CacheKey string `json:"cacheKey"`
|
||||
}
|
||||
|
||||
type Error struct {
|
||||
Code string
|
||||
Field string
|
||||
Detail string
|
||||
}
|
||||
|
||||
func (e Error) Error() string {
|
||||
if e.Field == "" {
|
||||
return e.Code + ": " + e.Detail
|
||||
}
|
||||
return e.Code + " (" + e.Field + "): " + e.Detail
|
||||
}
|
||||
|
||||
var ErrUnauthorized = Error{Code: "QUERY_UNAUTHORIZED", Detail: "a view-authorized principal is required"}
|
||||
|
||||
func (p Planner) CatalogVersion() string { return p.registry.Version() }
|
||||
|
||||
func NewPlanner(registry metriccatalog.Registry, limits Limits) Planner {
|
||||
if limits.MaxSeries == 0 {
|
||||
limits.MaxSeries = defaultMaxSeries
|
||||
}
|
||||
if limits.MaxPoints == 0 {
|
||||
limits.MaxPoints = defaultMaxPoints
|
||||
}
|
||||
if limits.MaxCostPoints == 0 {
|
||||
limits.MaxCostPoints = maxCostPoints
|
||||
}
|
||||
return Planner{registry: registry, limits: limits}
|
||||
}
|
||||
|
||||
type Planner struct {
|
||||
registry metriccatalog.Registry
|
||||
limits Limits
|
||||
}
|
||||
|
||||
func (p Planner) Plan(ctx context.Context, request Request) (Plan, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Plan{}, err
|
||||
}
|
||||
principal, ok := auth.PrincipalFromContext(ctx)
|
||||
if !ok || !auth.Allows(principal.Role, auth.PermissionView) {
|
||||
return Plan{}, ErrUnauthorized
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Plan{}, err
|
||||
}
|
||||
metricName := strings.TrimSpace(request.Metric)
|
||||
if metricName == "" {
|
||||
return Plan{}, Error{Code: "QUERY_METRIC_REQUIRED", Field: "metric", Detail: "metric is required"}
|
||||
}
|
||||
metric, ok := p.registry.Find(metricName)
|
||||
if !ok {
|
||||
return Plan{}, Error{Code: "QUERY_METRIC_UNKNOWN", Field: "metric", Detail: "metric is not in the approved catalog"}
|
||||
}
|
||||
resolvedScope, err := normalizeScope(request.Scope, metric.AllowedLabels)
|
||||
if err != nil {
|
||||
return Plan{}, err
|
||||
}
|
||||
groupBy, err := normalizeGroupBy(request.GroupBy, metric.AllowedLabels)
|
||||
if err != nil {
|
||||
return Plan{}, err
|
||||
}
|
||||
aggregation := request.Aggregation
|
||||
if aggregation == "" {
|
||||
aggregation = requestMetricDefault(metric)
|
||||
}
|
||||
if _, ok := allowedAggregations[aggregation]; !ok {
|
||||
return Plan{}, Error{Code: "QUERY_AGGREGATION_INVALID", Field: "aggregation", Detail: "aggregation is not allowed"}
|
||||
}
|
||||
if err := validateRange(request.Range, metric.Limits.MaxRangeSeconds); err != nil {
|
||||
return Plan{}, err
|
||||
}
|
||||
maxSeries := request.MaxSeries
|
||||
if maxSeries == 0 {
|
||||
maxSeries = min(defaultMaxSeries, metric.Limits.MaxSeries)
|
||||
}
|
||||
maxPoints := request.MaxPoints
|
||||
if maxPoints == 0 {
|
||||
maxPoints = min(defaultMaxPoints, metric.Limits.MaxPoints)
|
||||
}
|
||||
if maxSeries < 1 || maxSeries > metric.Limits.MaxSeries || maxSeries > p.limits.MaxSeries || maxSeries > metric.CardinalityBudget {
|
||||
return Plan{}, Error{Code: "QUERY_SERIES_LIMIT", Field: "maxSeries", Detail: "requested series exceed the metric or planner budget"}
|
||||
}
|
||||
if maxPoints < 10 || maxPoints > metric.Limits.MaxPoints || maxPoints > p.limits.MaxPoints {
|
||||
return Plan{}, Error{Code: "QUERY_POINT_LIMIT", Field: "maxPoints", Detail: "requested points exceed the metric or planner budget"}
|
||||
}
|
||||
estimatedPoints := int64(math.Ceil(request.Range.To.Sub(request.Range.From).Seconds() / float64(request.Range.StepSeconds)))
|
||||
if estimatedPoints < 1 || estimatedPoints > int64(maxPoints) {
|
||||
return Plan{}, Error{Code: "QUERY_POINT_LIMIT", Field: "range", Detail: "range and step exceed the point budget"}
|
||||
}
|
||||
estimatedSamples := estimatedPoints * int64(maxSeries)
|
||||
if estimatedSamples > p.limits.MaxCostPoints {
|
||||
return Plan{}, Error{Code: "QUERY_COST_LIMIT", Field: "range", Detail: "estimated query cost exceeds the planner budget"}
|
||||
}
|
||||
normalized := Request{Metric: metric.SemanticName, Scope: resolvedScope, Range: Range{From: request.Range.From.UTC(), To: request.Range.To.UTC(), StepSeconds: request.Range.StepSeconds}, Aggregation: aggregation, GroupBy: groupBy, MaxSeries: maxSeries, MaxPoints: maxPoints}
|
||||
keyBytes, err := json.Marshal(normalized)
|
||||
if err != nil {
|
||||
return Plan{}, fmt.Errorf("normalize query: %w", err)
|
||||
}
|
||||
digest := sha256.Sum256(keyBytes)
|
||||
return Plan{Metric: metric, Request: normalized, ResolvedScope: resolvedScope, Cost: Cost{Series: maxSeries, Points: int(estimatedPoints), EstimatedSamples: estimatedSamples}, CacheKey: hex.EncodeToString(digest[:])}, nil
|
||||
}
|
||||
|
||||
func normalizeScope(scope map[string]string, allowedLabels []string) (map[string]string, error) {
|
||||
if len(scope) > maxScope {
|
||||
return nil, Error{Code: "QUERY_SCOPE_LIMIT", Field: "scope", Detail: "scope has too many selectors"}
|
||||
}
|
||||
resolved := make(map[string]string, len(scope))
|
||||
allowed := make(map[string]struct{}, len(allowedLabels))
|
||||
for _, label := range allowedLabels {
|
||||
allowed[label] = struct{}{}
|
||||
}
|
||||
for alias, value := range scope {
|
||||
label, ok := scopeAliases[alias]
|
||||
if !ok {
|
||||
return nil, Error{Code: "QUERY_SCOPE_INVALID", Field: "scope." + alias, Detail: "scope alias is not allowed"}
|
||||
}
|
||||
if _, allowedLabel := allowed[label]; !allowedLabel {
|
||||
return nil, Error{Code: "QUERY_SCOPE_INVALID", Field: "scope." + alias, Detail: "scope alias is not supported by the metric"}
|
||||
}
|
||||
if !scopeValuePattern.MatchString(value) {
|
||||
return nil, Error{Code: "QUERY_SCOPE_INVALID", Field: "scope." + alias, Detail: "scope value contains unsupported characters"}
|
||||
}
|
||||
if previous, exists := resolved[label]; exists && previous != value {
|
||||
return nil, Error{Code: "QUERY_SCOPE_CONFLICT", Field: "scope." + alias, Detail: "scope aliases resolve to conflicting values"}
|
||||
}
|
||||
resolved[label] = value
|
||||
}
|
||||
return resolved, nil
|
||||
}
|
||||
|
||||
func normalizeGroupBy(groupBy, allowed []string) ([]string, error) {
|
||||
if len(groupBy) > maxGroupBy {
|
||||
return nil, Error{Code: "QUERY_GROUPING_LIMIT", Field: "groupBy", Detail: "too many grouping labels"}
|
||||
}
|
||||
allowedSet := make(map[string]struct{}, len(allowed))
|
||||
for _, label := range allowed {
|
||||
allowedSet[label] = struct{}{}
|
||||
}
|
||||
result := append([]string(nil), groupBy...)
|
||||
seen := make(map[string]struct{}, len(result))
|
||||
for _, label := range result {
|
||||
if _, ok := allowedSet[label]; !ok {
|
||||
return nil, Error{Code: "QUERY_LABEL_INVALID", Field: "groupBy", Detail: "label is not allowed for the metric"}
|
||||
}
|
||||
if _, ok := seen[label]; ok {
|
||||
return nil, Error{Code: "QUERY_LABEL_DUPLICATE", Field: "groupBy", Detail: "grouping labels must be unique"}
|
||||
}
|
||||
seen[label] = struct{}{}
|
||||
}
|
||||
sort.Strings(result)
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func validateRange(queryRange Range, maxRangeSeconds int) error {
|
||||
if queryRange.From.IsZero() || queryRange.To.IsZero() || !queryRange.From.Before(queryRange.To) {
|
||||
return Error{Code: "QUERY_RANGE_INVALID", Field: "range", Detail: "from must be before to"}
|
||||
}
|
||||
if queryRange.From.Location() == nil || queryRange.To.Location() == nil {
|
||||
return Error{Code: "QUERY_RANGE_INVALID", Field: "range", Detail: "timestamps must include a timezone"}
|
||||
}
|
||||
if queryRange.To.Sub(queryRange.From) > time.Duration(maxRangeSeconds)*time.Second {
|
||||
return Error{Code: "QUERY_RANGE_LIMIT", Field: "range", Detail: "range exceeds the metric limit"}
|
||||
}
|
||||
if queryRange.StepSeconds < 1 || queryRange.StepSeconds > 86400 {
|
||||
return Error{Code: "QUERY_STEP_INVALID", Field: "range.stepSeconds", Detail: "step must be between 1 second and 24 hours"}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func requestMetricDefault(metric metriccatalog.Definition) string {
|
||||
if metric.DefaultAggregation == "" {
|
||||
return "none"
|
||||
}
|
||||
return metric.DefaultAggregation
|
||||
}
|
||||
func min(a, b int) int {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
Reference in New Issue
Block a user