chore: update formula

pkg/types/querybuildertypes/querybuildertypesv5/formula.go

@@ -4,11 +4,15 @@ import (
 	"fmt"
 	"math"
 	"sort"
+	"strconv"
+	"strings"
+	"sync"
 	"time"
 
+	"slices"
+
 	"github.com/SigNoz/govaluate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 type QueryBuilderFormula struct {
@@ -21,107 +25,233 @@ type QueryBuilderFormula struct {
 	Functions []Function `json:"functions,omitempty"`
 }
 
-// FormulaEvaluator handles formula evaluation for QBv5 types
+type aggregationRef struct {
-type FormulaEvaluator struct {
+	QueryName string
-	expression     *govaluate.EvaluableExpression
+	Index     *int    // Index-based reference (e.g., A.0)
-	canDefaultZero map[string]bool
+	Alias     *string // Alias-based reference (e.g., A.my_alias)
-	functions      map[string]govaluate.ExpressionFunction
 }
 
-// NewFormulaEvaluator creates a new formula evaluator
+// seriesLookup provides lookup for series data
+type seriesLookup struct {
+	// seriesKey -> timestamp -> value
+	data map[string]map[int64]float64
+	// seriesKey -> original series for metadata preservation
+	seriesMetadata map[string]*TimeSeries
+}
+
+// FormulaEvaluator handles formula evaluation b/w time series from different aggregations
+type FormulaEvaluator struct {
+	expression     *govaluate.EvaluableExpression
+	variables      []string
+	canDefaultZero map[string]bool
+
+	// Parsed aggregation references from variables
+	aggRefs map[string]aggregationRef
+
+	timestampPool sync.Pool
+	valuesPool    sync.Pool
+}
+
+// NewFormulaEvaluator creates a formula evaluator
 func NewFormulaEvaluator(expressionStr string, canDefaultZero map[string]bool) (*FormulaEvaluator, error) {
 	functions := EvalFuncs()
 	expression, err := govaluate.NewEvaluableExpressionWithFunctions(expressionStr, functions)
 	if err != nil {
-		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to parse expression: %s, error: %s", expressionStr, err.Error())
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to parse expression")
 	}
 
-	return &FormulaEvaluator{
+	evaluator := &FormulaEvaluator{
 		expression:     expression,
+		variables:      expression.Vars(),
 		canDefaultZero: canDefaultZero,
-		functions:      functions,
+		aggRefs:        make(map[string]aggregationRef),
-	}, nil
+	}
-}
 
-// EvaluateFormula processes multiple time series data and evaluates the formula
+	// Parse aggregation references from variables
-func (fe *FormulaEvaluator) EvaluateFormula(timeSeriesData map[string]*TimeSeriesData) (*TimeSeriesData, error) {
+	for _, variable := range evaluator.variables {
-	// Convert TimeSeriesData to a flattened series map for processing
+		aggRef, err := parseAggregationReference(variable)
-	allSeries := fe.flattenTimeSeriesData(timeSeriesData)
-
-	// Find unique label sets for formula evaluation
-	uniqueLabelSets := fe.findUniqueLabelSets(allSeries)
-
-	// Process each unique label set
-	var resultSeries []*TimeSeries
-	for _, labelSet := range uniqueLabelSets {
-		series, err := fe.joinAndCalculate(allSeries, labelSet)
 		if err != nil {
 			return nil, err
 		}
-		if series != nil && len(series.Values) > 0 {
+		evaluator.aggRefs[variable] = aggRef
-			resultSeries = append(resultSeries, series)
-		}
 	}
 
-	return &TimeSeriesData{
+	evaluator.timestampPool.New = func() any {
-		QueryName: "formula",
+		return make([]int64, 0, 1000)
-		Aggregations: []*AggregationBucket{
+	}
-			{
+	evaluator.valuesPool.New = func() any {
-				Index:  0,
+		return make(map[string]any, len(evaluator.variables))
-				Alias:  "formula_result",
+	}
-				Series: resultSeries,
+
-			},
+	return evaluator, nil
-		},
-	}, nil
 }
 
-// flattenTimeSeriesData converts map of TimeSeriesData to a flat map of series by query name
+// parseAggregationReference parses variable names like "A", "A.0", "A.my_alias"
-func (fe *FormulaEvaluator) flattenTimeSeriesData(timeSeriesData map[string]*TimeSeriesData) map[string][]*TimeSeries {
+func parseAggregationReference(variable string) (aggregationRef, error) {
-	result := make(map[string][]*TimeSeries)
+	parts := strings.Split(variable, ".")
 
-	for queryName, data := range timeSeriesData {
+	if len(parts) == 1 {
-		var allSeries []*TimeSeries
+		// Simple query reference like "A" - defaults to first aggregation (index 0)
-		for _, bucket := range data.Aggregations {
+		defaultIndex := 0
-			allSeries = append(allSeries, bucket.Series...)
+		return aggregationRef{
-		}
+			QueryName: parts[0],
-		result[queryName] = allSeries
+			Index:     &defaultIndex,
+		}, nil
 	}
 
-	return result
+	if len(parts) == 2 {
+		queryName := parts[0]
+		reference := parts[1]
+
+		// Try to parse as index
+		if index, err := strconv.Atoi(reference); err == nil {
+			return aggregationRef{
+				QueryName: queryName,
+				Index:     &index,
+			}, nil
+		}
+
+		// Otherwise treat as alias
+		return aggregationRef{
+			QueryName: queryName,
+			Alias:     &reference,
+		}, nil
+	}
+
+	return aggregationRef{}, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid aggregation reference %q", variable)
 }
 
-// findUniqueLabelSets finds all unique label combinations across series that are referenced in the expression
+// EvaluateFormula processes multiple time series with proper aggregation handling
-func (fe *FormulaEvaluator) findUniqueLabelSets(allSeries map[string][]*TimeSeries) []map[string]string {
+func (fe *FormulaEvaluator) EvaluateFormula(timeSeriesData map[string]*TimeSeriesData) ([]*TimeSeries, error) {
-	queriesInExpression := make(map[string]struct{})
+	// Build lookup structures for all referenced aggregations
-	for _, v := range fe.expression.Vars() {
+	lookup := fe.buildSeriesLookup(timeSeriesData)
-		queriesInExpression[v] = struct{}{}
+
+	// Find all unique label combinations across referenced series
+	uniqueLabelSets := fe.findUniqueLabelSets(lookup)
+
+	// Process each unique label set
+	var resultSeries []*TimeSeries
+	var wg sync.WaitGroup
+	resultChan := make(chan *TimeSeries, len(uniqueLabelSets))
+	semaphore := make(chan struct{}, 4) // Limit concurrency
+
+	for _, labelSet := range uniqueLabelSets {
+		wg.Add(1)
+		go func(labels []*Label) {
+			defer wg.Done()
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }()
+
+			series := fe.evaluateForLabelSet(labels, lookup)
+			if series != nil && len(series.Values) > 0 {
+				resultChan <- series
+			}
+		}(labelSet)
 	}
 
-	var allLabelSets []map[string]string
+	go func() {
+		wg.Wait()
+		close(resultChan)
+	}()
 
-	// Collect all label sets from series that are referenced in the expression
+	for series := range resultChan {
-	for queryName, series := range allSeries {
+		resultSeries = append(resultSeries, series)
-		if _, ok := queriesInExpression[queryName]; !ok {
+	}
+
+	return resultSeries, nil
+}
+
+// buildSeriesLookup creates lookup structure for all referenced aggregations
+func (fe *FormulaEvaluator) buildSeriesLookup(timeSeriesData map[string]*TimeSeriesData) *seriesLookup {
+	lookup := &seriesLookup{
+		data:           make(map[string]map[int64]float64),
+		seriesMetadata: make(map[string]*TimeSeries),
+	}
+
+	for variable, aggRef := range fe.aggRefs {
+		data, exists := timeSeriesData[aggRef.QueryName]
+		if !exists {
 			continue
 		}
 
-		for _, s := range series {
+		// Find the specific aggregation bucket
-			labelMap := fe.labelsToMap(s.Labels)
+		var targetBucket *AggregationBucket
-			allLabelSets = append(allLabelSets, labelMap)
+		for _, bucket := range data.Aggregations {
+			if aggRef.Index != nil && bucket.Index == *aggRef.Index {
+				targetBucket = bucket
+				break
+			}
+			if aggRef.Alias != nil && bucket.Alias == *aggRef.Alias {
+				targetBucket = bucket
+				break
+			}
+		}
+
+		if targetBucket == nil {
+			continue
+		}
+
+		// Process all series in the target bucket
+		for seriesIdx, series := range targetBucket.Series {
+			seriesKey := fe.buildSeriesKey(variable, seriesIdx, series.Labels)
+
+			// Initialize timestamp map
+			if _, exists := lookup.data[seriesKey]; !exists {
+				lookup.data[seriesKey] = make(map[int64]float64, len(series.Values))
+				lookup.seriesMetadata[seriesKey] = series
+			}
+
+			// Store all timestamp-value pairs
+			for _, value := range series.Values {
+				lookup.data[seriesKey][value.Timestamp] = value.Value
+			}
 		}
 	}
 
-	// Sort by number of labels (descending) for subset detection optimization
+	return lookup
+}
+
+// buildSeriesKey creates a unique key for a series within a specific aggregation
+func (fe *FormulaEvaluator) buildSeriesKey(variable string, seriesIndex int, labels []*Label) string {
+	// Create a deterministic key that includes variable and label information
+	var keyParts []string
+	keyParts = append(keyParts, variable)
+	keyParts = append(keyParts, strconv.Itoa(seriesIndex))
+
+	// Sort labels by key name for consistent ordering
+	sortedLabels := make([]*Label, len(labels))
+	copy(sortedLabels, labels)
+	sort.Slice(sortedLabels, func(i, j int) bool {
+		return sortedLabels[i].Key.Name < sortedLabels[j].Key.Name
+	})
+
+	for _, label := range sortedLabels {
+		keyParts = append(keyParts, fmt.Sprintf("%s=%v", label.Key.Name, label.Value))
+	}
+
+	return strings.Join(keyParts, "|")
+}
+
+// findUniqueLabelSets finds all unique label combinations across all referenced series
+func (fe *FormulaEvaluator) findUniqueLabelSets(lookup *seriesLookup) [][]*Label {
+	var allLabelSets [][]*Label
+
+	// Collect all label sets from series metadata
+	for _, series := range lookup.seriesMetadata {
+		allLabelSets = append(allLabelSets, series.Labels)
+	}
+
+	// sort the label sets by the number of labels in descending order
 	sort.Slice(allLabelSets, func(i, j int) bool {
 		return len(allLabelSets[i]) > len(allLabelSets[j])
 	})
 
-	// Find unique label sets (remove subsets)
+	// Find unique label sets using proper label comparison
-	var uniqueSets []map[string]string
+	var uniqueSets [][]*Label
 	for _, labelSet := range allLabelSets {
 		isUnique := true
-		for _, uniqueLabelSet := range uniqueSets {
+		for _, uniqueSet := range uniqueSets {
-			if fe.isSubset(uniqueLabelSet, labelSet) {
+			if fe.isSubset(uniqueSet, labelSet) {
 				isUnique = false
 				break
 			}
@@ -134,92 +264,130 @@ func (fe *FormulaEvaluator) findUniqueLabelSets(allSeries map[string][]*TimeSeri
 	return uniqueSets
 }
 
-// joinAndCalculate joins series with matching labels and evaluates the formula at each timestamp
+func (fe *FormulaEvaluator) isSubset(labels1, labels2 []*Label) bool {
-func (fe *FormulaEvaluator) joinAndCalculate(allSeries map[string][]*TimeSeries, uniqueLabelSet map[string]string) (*TimeSeries, error) {
+	labelMap1 := make(map[string]any)
-	// Map to store values: queryName -> timestamp -> value
+	labelMap2 := make(map[string]any)
-	seriesMap := make(map[string]map[int64]float64)
-	uniqueTimestamps := make(map[int64]struct{})
 
-	// Find matching series for each query and build lookup maps
+	for _, label := range labels1 {
-	for queryName, seriesList := range allSeries {
+		labelMap1[label.Key.Name] = label.Value
-		var matchingSeries *TimeSeries
+	}
+	for _, label := range labels2 {
+		labelMap2[label.Key.Name] = label.Value
+	}
 
-		// Find a series that matches the current label set
+	for k, v := range labelMap2 {
-		for _, series := range seriesList {
+		if val, ok := labelMap1[k]; !ok || val != v {
-			seriesLabelMap := fe.labelsToMap(series.Labels)
+			return false
-			if fe.isSubset(uniqueLabelSet, seriesLabelMap) {
-				matchingSeries = series
-				break
-			}
 		}
+	}
+	return true
+}
 
-		// Build timestamp -> value mapping for quick lookup
+// labelsEqual compares two label sets for equality
-		if matchingSeries != nil {
+func (fe *FormulaEvaluator) labelsEqual(labels1, labels2 []*Label) bool {
-			if _, ok := seriesMap[queryName]; !ok {
+	if len(labels1) != len(labels2) {
-				seriesMap[queryName] = make(map[int64]float64)
+		return false
-			}
+	}
 
-			for _, point := range matchingSeries.Values {
+	// Create maps for comparison
-				seriesMap[queryName][point.Timestamp] = point.Value
+	map1 := make(map[string]any)
-				uniqueTimestamps[point.Timestamp] = struct{}{}
+	map2 := make(map[string]any)
+
+	for _, label := range labels1 {
+		map1[label.Key.Name] = label.Value
+	}
+	for _, label := range labels2 {
+		map2[label.Key.Name] = label.Value
+	}
+
+	if len(map1) != len(map2) {
+		return false
+	}
+
+	for k, v1 := range map1 {
+		if v2, exists := map2[k]; !exists || v1 != v2 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// evaluateForLabelSet performs formula evaluation for a specific label set
+func (fe *FormulaEvaluator) evaluateForLabelSet(targetLabels []*Label, lookup *seriesLookup) *TimeSeries {
+	// Find matching series for each variable
+	variableData := make(map[string]map[int64]float64)
+	var allTimestamps map[int64]struct{} = make(map[int64]struct{})
+
+	for variable := range fe.aggRefs {
+		// Find series with matching labels for this variable
+		for seriesKey, series := range lookup.seriesMetadata {
+			if strings.HasPrefix(seriesKey, variable+"|") && fe.isSubset(targetLabels, series.Labels) {
+				if timestampData, exists := lookup.data[seriesKey]; exists {
+					variableData[variable] = timestampData
+					// Collect all timestamps
+					for ts := range timestampData {
+						allTimestamps[ts] = struct{}{}
+					}
+					break // Found matching series for this variable
+				}
 			}
 		}
 	}
 
-	// Convert unique timestamps to sorted slice
+	// Convert timestamps to sorted slice
-	timestamps := make([]int64, 0, len(uniqueTimestamps))
+	timestamps := fe.timestampPool.Get().([]int64)
-	for timestamp := range uniqueTimestamps {
+	timestamps = timestamps[:0]
-		timestamps = append(timestamps, timestamp)
+	defer fe.timestampPool.Put(timestamps)
+
+	for ts := range allTimestamps {
+		timestamps = append(timestamps, ts)
 	}
-	sort.Slice(timestamps, func(i, j int) bool {
+	slices.Sort(timestamps)
-		return timestamps[i] < timestamps[j]
-	})
 
 	// Evaluate formula at each timestamp
 	var resultValues []*TimeSeriesValue
+	values := fe.valuesPool.Get().(map[string]any)
+	defer fe.valuesPool.Put(values)
+
 	for _, timestamp := range timestamps {
-		values := make(map[string]interface{})
+		// Clear previous values
+		for k := range values {
+			delete(values, k)
+		}
 
 		// Collect values for this timestamp
-		for queryName, series := range seriesMap {
+		validCount := 0
-			if value, ok := series[timestamp]; ok {
+		for _, variable := range fe.variables {
-				values[queryName] = value
+			if varData, exists := variableData[variable]; exists {
+				if value, exists := varData[timestamp]; exists {
+					values[variable] = value
+					validCount++
+				}
 			}
 		}
 
-		// Set default zeros where allowed
+		// Apply default zeros where allowed
-		for _, variable := range fe.expression.Vars() {
+		for _, variable := range fe.variables {
-			if _, ok := values[variable]; !ok && fe.canDefaultZero[variable] {
+			if _, exists := values[variable]; !exists && fe.canDefaultZero[variable] {
 				values[variable] = 0.0
+				validCount++
 			}
 		}
 
-		// Check if we have all required variables
+		// Skip if we don't have all required variables
-		canEvaluate := true
+		if validCount != len(fe.variables) {
-		for _, variable := range fe.expression.Vars() {
-			if _, ok := values[variable]; !ok {
-				canEvaluate = false
-				break
-			}
-		}
-
-		if !canEvaluate {
 			continue
 		}
 
-		// Evaluate the expression
+		// Evaluate expression
 		result, err := fe.expression.Evaluate(values)
 		if err != nil {
-			return nil, fmt.Errorf("expression evaluation failed at timestamp %d: %w", timestamp, err)
+			continue
 		}
 
 		value, ok := result.(float64)
-		if !ok {
+		if !ok || math.IsNaN(value) || math.IsInf(value, 0) {
-			return nil, fmt.Errorf("expression result is not float64: %T", result)
-		}
-
-		// Skip invalid values
-		if math.IsNaN(value) || math.IsInf(value, 0) {
 			continue
 		}
 
@@ -229,129 +397,97 @@ func (fe *FormulaEvaluator) joinAndCalculate(allSeries map[string][]*TimeSeries,
 		})
 	}
 
-	// Convert label map back to Label slice
+	if len(resultValues) == 0 {
-	resultLabels := fe.mapToLabels(uniqueLabelSet)
+		return nil
+	}
+
+	// Preserve original label structure and metadata
+	resultLabels := make([]*Label, len(targetLabels))
+	copy(resultLabels, targetLabels)
 
 	return &TimeSeries{
 		Labels: resultLabels,
 		Values: resultValues,
-	}, nil
-}
-
-// Helper functions
-
-// isSubset checks if 'sub' is a subset of 'super'
-func (fe *FormulaEvaluator) isSubset(super, sub map[string]string) bool {
-	for k, v := range sub {
-		if val, ok := super[k]; !ok || val != v {
-			return false
-		}
 	}
-	return true
 }
 
-// labelsToMap converts Label slice to map for easier comparison
+// EvalFuncs returns mathematical functions
-func (fe *FormulaEvaluator) labelsToMap(labels []*Label) map[string]string {
-	result := make(map[string]string)
-	for _, label := range labels {
-		if strVal, ok := label.Value.(string); ok {
-			result[label.Key.Name] = strVal
-		} else {
-			result[label.Key.Name] = convertValueToString(label.Value)
-		}
-	}
-	return result
-}
-
-// mapToLabels converts map back to Label slice
-func (fe *FormulaEvaluator) mapToLabels(labelMap map[string]string) []*Label {
-	var labels []*Label
-	for key, value := range labelMap {
-		labels = append(labels, &Label{
-			Key: telemetrytypes.TelemetryFieldKey{
-				Name:          key,
-				FieldDataType: telemetrytypes.FieldDataTypeString,
-			},
-			Value: value,
-		})
-	}
-	return labels
-}
-
-// EvalFuncs returns the supported mathematical functions for formula evaluation
 func EvalFuncs() map[string]govaluate.ExpressionFunction {
 	funcs := make(map[string]govaluate.ExpressionFunction)
 
+	pi180 := math.Pi / 180
+	rad180 := 180 / math.Pi
+
 	// Mathematical functions
-	funcs["exp"] = func(args ...interface{}) (interface{}, error) {
+	funcs["exp"] = func(args ...any) (any, error) {
 		return math.Exp(args[0].(float64)), nil
 	}
-	funcs["log"] = func(args ...interface{}) (interface{}, error) {
+	funcs["log"] = func(args ...any) (any, error) {
 		return math.Log(args[0].(float64)), nil
 	}
-	funcs["ln"] = func(args ...interface{}) (interface{}, error) {
+	funcs["ln"] = func(args ...any) (any, error) {
 		return math.Log(args[0].(float64)), nil
 	}
-	funcs["exp2"] = func(args ...interface{}) (interface{}, error) {
+	funcs["exp2"] = func(args ...any) (any, error) {
 		return math.Exp2(args[0].(float64)), nil
 	}
-	funcs["log2"] = func(args ...interface{}) (interface{}, error) {
+	funcs["log2"] = func(args ...any) (any, error) {
 		return math.Log2(args[0].(float64)), nil
 	}
-	funcs["exp10"] = func(args ...interface{}) (interface{}, error) {
+	funcs["exp10"] = func(args ...any) (any, error) {
 		return math.Pow10(int(args[0].(float64))), nil
 	}
-	funcs["log10"] = func(args ...interface{}) (interface{}, error) {
+	funcs["log10"] = func(args ...any) (any, error) {
 		return math.Log10(args[0].(float64)), nil
 	}
-	funcs["sqrt"] = func(args ...interface{}) (interface{}, error) {
+	funcs["sqrt"] = func(args ...any) (any, error) {
 		return math.Sqrt(args[0].(float64)), nil
 	}
-	funcs["cbrt"] = func(args ...interface{}) (interface{}, error) {
+	funcs["cbrt"] = func(args ...any) (any, error) {
 		return math.Cbrt(args[0].(float64)), nil
 	}
-	funcs["erf"] = func(args ...interface{}) (interface{}, error) {
+	funcs["erf"] = func(args ...any) (any, error) {
 		return math.Erf(args[0].(float64)), nil
 	}
-	funcs["erfc"] = func(args ...interface{}) (interface{}, error) {
+	funcs["erfc"] = func(args ...any) (any, error) {
 		return math.Erfc(args[0].(float64)), nil
 	}
-	funcs["lgamma"] = func(args ...interface{}) (interface{}, error) {
+	funcs["lgamma"] = func(args ...any) (any, error) {
 		v, _ := math.Lgamma(args[0].(float64))
 		return v, nil
 	}
-	funcs["tgamma"] = func(args ...interface{}) (interface{}, error) {
+	funcs["tgamma"] = func(args ...any) (any, error) {
 		return math.Gamma(args[0].(float64)), nil
 	}
 
 	// Trigonometric functions
-	funcs["sin"] = func(args ...interface{}) (interface{}, error) {
+	funcs["sin"] = func(args ...any) (any, error) {
 		return math.Sin(args[0].(float64)), nil
 	}
-	funcs["cos"] = func(args ...interface{}) (interface{}, error) {
+	funcs["cos"] = func(args ...any) (any, error) {
 		return math.Cos(args[0].(float64)), nil
 	}
-	funcs["tan"] = func(args ...interface{}) (interface{}, error) {
+	funcs["tan"] = func(args ...any) (any, error) {
 		return math.Tan(args[0].(float64)), nil
 	}
-	funcs["asin"] = func(args ...interface{}) (interface{}, error) {
+	funcs["asin"] = func(args ...any) (any, error) {
 		return math.Asin(args[0].(float64)), nil
 	}
-	funcs["acos"] = func(args ...interface{}) (interface{}, error) {
+	funcs["acos"] = func(args ...any) (any, error) {
 		return math.Acos(args[0].(float64)), nil
 	}
-	funcs["atan"] = func(args ...interface{}) (interface{}, error) {
+	funcs["atan"] = func(args ...any) (any, error) {
 		return math.Atan(args[0].(float64)), nil
 	}
 
-	// Utility functions
+	// Utility functions (optimized with pre-computed constants)
-	funcs["degrees"] = func(args ...interface{}) (interface{}, error) {
+	funcs["degrees"] = func(args ...any) (any, error) {
-		return args[0].(float64) * 180 / math.Pi, nil
+		return args[0].(float64) * rad180, nil
 	}
-	funcs["radians"] = func(args ...interface{}) (interface{}, error) {
+	funcs["radians"] = func(args ...any) (any, error) {
-		return args[0].(float64) * math.Pi / 180, nil
+		return args[0].(float64) * pi180, nil
 	}
-	funcs["now"] = func(args ...interface{}) (interface{}, error) {
+	funcs["now"] = func(args ...any) (any, error) {
 		return float64(time.Now().Unix()), nil
 	}
 

pkg/types/querybuildertypes/querybuildertypesv5/formula_test.go

@@ -0,0 +1,865 @@
+package querybuildertypesv5
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func createFormulaTestTimeSeriesData(queryName string, series []*TimeSeries) *TimeSeriesData {
+	return &TimeSeriesData{
+		QueryName: queryName,
+		Aggregations: []*AggregationBucket{
+			{
+				Index:  0,
+				Alias:  queryName + "_agg",
+				Series: series,
+			},
+		},
+	}
+}
+
+func createLabels(labelMap map[string]string) []*Label {
+	var labels []*Label
+	for key, value := range labelMap {
+		labels = append(labels, &Label{
+			Key: telemetrytypes.TelemetryFieldKey{
+				Name:          key,
+				FieldDataType: telemetrytypes.FieldDataTypeString,
+			},
+			Value: value,
+		})
+	}
+	return labels
+}
+
+func createValues(points map[int64]float64) []*TimeSeriesValue {
+	var values []*TimeSeriesValue
+	for timestamp, value := range points {
+		values = append(values, &TimeSeriesValue{
+			Timestamp: timestamp,
+			Value:     value,
+		})
+	}
+	return values
+}
+
+func TestFindUniqueLabelSets(t *testing.T) {
+	tests := []struct {
+		name       string
+		tsData     map[string]*TimeSeriesData
+		expression string
+		expected   int // number of unique label sets
+	}{
+		{
+			name: "two distinct label sets",
+			tsData: map[string]*TimeSeriesData{
+				"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+							"operation":    "GET /api",
+						}),
+						Values: createValues(map[int64]float64{1: 10}),
+					},
+				}),
+				"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "redis",
+						}),
+						Values: createValues(map[int64]float64{1: 30}),
+					},
+				}),
+			},
+			expression: "A + B",
+			expected:   2,
+		},
+		{
+			name: "subset elimination test",
+			tsData: map[string]*TimeSeriesData{
+				"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+							"operation":    "GET /api",
+						}),
+						Values: createValues(map[int64]float64{1: 10}),
+					},
+				}),
+				"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+						}),
+						Values: createValues(map[int64]float64{1: 30}),
+					},
+				}),
+				"C": createFormulaTestTimeSeriesData("C", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"operation": "PUT /api",
+						}),
+						Values: createValues(map[int64]float64{1: 30}),
+					},
+				}),
+				"D": createFormulaTestTimeSeriesData("D", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+							"http_status":  "200",
+						}),
+						Values: createValues(map[int64]float64{1: 30}),
+					},
+				}),
+			},
+			expression: "A + B + C + D",
+			expected:   3, // Three unique label sets after subset elimination
+		},
+		{
+			name: "empty series",
+			tsData: map[string]*TimeSeriesData{
+				"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{}),
+				"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{}),
+			},
+			expression: "A + B",
+			expected:   0,
+		},
+		{
+			name: "overlapping labels",
+			tsData: map[string]*TimeSeriesData{
+				"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+							"operation":    "GET /api",
+						}),
+						Values: createValues(map[int64]float64{1: 10}),
+					},
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "redis",
+							"operation":    "GET /api",
+						}),
+						Values: createValues(map[int64]float64{1: 12}),
+					},
+				}),
+				"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "redis",
+						}),
+						Values: createValues(map[int64]float64{1: 30}),
+					},
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+						}),
+						Values: createValues(map[int64]float64{1: 25}),
+					},
+				}),
+			},
+			expression: "A + B",
+			expected:   2, // Two unique label sets after subset detection
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			evaluator, err := NewFormulaEvaluator(tt.expression, map[string]bool{"A": false, "B": false})
+			require.NoError(t, err)
+
+			lookup := evaluator.buildSeriesLookup(tt.tsData)
+			uniqueLabelSets := evaluator.findUniqueLabelSets(lookup)
+
+			assert.Equal(t, tt.expected, len(uniqueLabelSets))
+		})
+	}
+}
+
+func TestBasicFormulaEvaluation(t *testing.T) {
+	tests := []struct {
+		name       string
+		tsData     map[string]*TimeSeriesData
+		expression string
+		expected   int // number of result series
+	}{
+		{
+			name: "simple addition",
+			tsData: map[string]*TimeSeriesData{
+				"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "frontend",
+							"operation":    "GET /api",
+						}),
+						Values: createValues(map[int64]float64{
+							1: 10,
+							2: 20,
+						}),
+					},
+				}),
+				"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{
+							"service_name": "redis",
+						}),
+						Values: createValues(map[int64]float64{
+							1: 30,
+							3: 40,
+						}),
+					},
+				}),
+			},
+			expression: "A + B",
+			expected:   2,
+		},
+		{
+			name: "division with zeros",
+			tsData: map[string]*TimeSeriesData{
+				"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{}),
+						Values: createValues(map[int64]float64{
+							1: 10,
+							2: 0,
+						}),
+					},
+				}),
+				"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+					{
+						Labels: createLabels(map[string]string{}),
+						Values: createValues(map[int64]float64{
+							1: 0,
+							3: 10,
+						}),
+					},
+				}),
+			},
+			expression: "A/B",
+			expected:   1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			evaluator, err := NewFormulaEvaluator(tt.expression, map[string]bool{"A": true, "B": true})
+			require.NoError(t, err)
+
+			result, err := evaluator.EvaluateFormula(tt.tsData)
+			require.NoError(t, err)
+			require.NotNil(t, result)
+
+			assert.Equal(t, tt.expected, len(result))
+		})
+	}
+}
+
+func TestErrorRateCalculation(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "frontend",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "redis",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "route",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 2,
+					2: 45,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "redis",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 6,
+					2: 9,
+				}),
+			},
+		}),
+	}
+
+	evaluator, err := NewFormulaEvaluator("B/A", map[string]bool{"A": true, "B": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 3 result series (frontend gets 0, redis gets calculated values, route gets 0)
+	assert.Equal(t, 3, len(result))
+
+	// Find the redis series and check its values
+	for _, series := range result {
+		for _, label := range series.Labels {
+			if label.Key.Name == "service_name" && label.Value == "redis" {
+				assert.Len(t, series.Values, 2)
+				assert.Equal(t, 0.5, series.Values[0].Value) // 6/12
+				assert.Equal(t, 0.2, series.Values[1].Value) // 9/45
+			}
+		}
+	}
+}
+
+func TestNoGroupKeysOnLeftSide(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "frontend",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "redis",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+				}),
+			},
+		}),
+	}
+
+	evaluator, err := NewFormulaEvaluator("B/A", map[string]bool{"A": true, "B": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 2 result series (frontend and redis)
+	assert.Equal(t, 2, len(result))
+
+	// Verify calculations
+	expectedValues := map[string][]float64{
+		"frontend": {2.2, 3.25},                              // 22/10, 65/20
+		"redis":    {1.8333333333333333, 1.4444444444444444}, // 22/12, 65/45
+	}
+
+	for _, series := range result {
+		for _, label := range series.Labels {
+			if label.Key.Name == "service_name" {
+				serviceName := label.Value.(string)
+				if expected, exists := expectedValues[serviceName]; exists {
+					assert.Len(t, series.Values, len(expected))
+					for i, expectedVal := range expected {
+						assert.InDelta(t, expectedVal, series.Values[i].Value, 0.0001)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestSameGroupKeys(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "running",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+					4: 40,
+					5: 50,
+					7: 70,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "idle",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "running",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "idle",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+	}
+
+	evaluator, err := NewFormulaEvaluator("A/B", map[string]bool{"A": true, "B": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 2 result series
+	assert.Equal(t, 2, len(result))
+
+	// Verify that we get the expected calculations
+	for _, series := range result {
+		hostName := ""
+		state := ""
+		for _, label := range series.Labels {
+			if label.Key.Name == "host_name" {
+				hostName = label.Value.(string)
+			}
+			if label.Key.Name == "state" {
+				state = label.Value.(string)
+			}
+		}
+
+		if hostName == "ip-10-420-69-1" && state == "running" {
+			// Check specific calculations
+			assert.Equal(t, float64(10)/float64(22), series.Values[0].Value)      // timestamp 1
+			assert.InDelta(t, 0.3076923076923077, series.Values[1].Value, 0.0001) // timestamp 2
+		}
+	}
+}
+
+func TestGroupKeysDifferentValues(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "running",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+					4: 40,
+					5: 50,
+					7: 70,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "idle",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "not_running_chalamet",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "busy",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+	}
+
+	evaluator, err := NewFormulaEvaluator("A/B", map[string]bool{"A": true, "B": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 2 result series with all zero values (no label matches)
+	assert.Equal(t, 2, len(result))
+
+	for _, series := range result {
+		for _, value := range series.Values {
+			assert.Equal(t, 0.0, value.Value) // All values should be 0 due to default zero
+		}
+	}
+}
+
+func TestLeftSideSuperset(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "running",
+					"os.type":   "linux",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+					4: 40,
+					5: 50,
+					7: 70,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "idle",
+					"os.type":   "linux",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"state":   "running",
+					"os.type": "linux",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"state":   "busy",
+					"os.type": "linux",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+	}
+
+	evaluator, err := NewFormulaEvaluator("A/B", map[string]bool{"A": true, "B": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 2 result series
+	assert.Equal(t, 2, len(result))
+
+	// Find the running series and verify calculation
+	for _, series := range result {
+		hasRunning := false
+		hasHost := false
+		for _, label := range series.Labels {
+			if label.Key.Name == "state" && label.Value == "running" {
+				hasRunning = true
+			}
+			if label.Key.Name == "host_name" {
+				hasHost = true
+			}
+		}
+
+		if hasRunning && hasHost {
+			// This should be the matched series
+			assert.Equal(t, float64(10)/float64(22), series.Values[0].Value)      // timestamp 1
+			assert.InDelta(t, 0.3076923076923077, series.Values[1].Value, 0.0001) // timestamp 2
+		}
+	}
+}
+
+func TestNoDefaultZero(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "frontend",
+					"operation":    "GET /api",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "redis",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 30,
+					3: 40,
+				}),
+			},
+		}),
+	}
+
+	// No default zero - should have no results since label sets don't match
+	evaluator, err := NewFormulaEvaluator("A + B", map[string]bool{"A": false, "B": false})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+
+	// Should have no result series since labels don't match and no default zero
+	assert.Equal(t, 0, len(result))
+}
+
+func TestMixedQueries(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "frontend",
+					"operation":    "GET /api",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "frontend",
+					"operation":    "GET /api",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+				}),
+			},
+		}),
+		"C": createFormulaTestTimeSeriesData("C", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"service_name": "redis",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 30,
+					2: 50,
+					3: 45,
+				}),
+			},
+		}),
+	}
+
+	evaluator, err := NewFormulaEvaluator("A / B", map[string]bool{"A": true, "B": true, "C": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 1 result series (only A and B have matching labels)
+	assert.Equal(t, 1, len(result))
+
+	// Verify the result is A/B = 1 for matching timestamps
+	series := result[0]
+	assert.Len(t, series.Values, 2)
+	assert.Equal(t, 1.0, series.Values[0].Value) // 10/10
+	assert.Equal(t, 1.0, series.Values[1].Value) // 20/20
+}
+
+func TestComplexExpression(t *testing.T) {
+	tsData := map[string]*TimeSeriesData{
+		"A": createFormulaTestTimeSeriesData("A", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"state": "running",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+					4: 40,
+					5: 50,
+					7: 70,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"state": "idle",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+		"B": createFormulaTestTimeSeriesData("B", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "running",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "idle",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 22,
+					2: 65,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+		"C": createFormulaTestTimeSeriesData("C", []*TimeSeries{
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-1",
+					"state":     "running",
+					"os.type":   "linux",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 10,
+					2: 20,
+					4: 40,
+					5: 50,
+					7: 70,
+				}),
+			},
+			{
+				Labels: createLabels(map[string]string{
+					"host_name": "ip-10-420-69-2",
+					"state":     "idle",
+					"os.type":   "linux",
+				}),
+				Values: createValues(map[int64]float64{
+					1: 12,
+					2: 45,
+					3: 30,
+					4: 40,
+					5: 50,
+				}),
+			},
+		}),
+	}
+
+	// Complex expression: A/B + C
+	evaluator, err := NewFormulaEvaluator("A/B + C", map[string]bool{"A": true, "B": true, "C": true})
+	require.NoError(t, err)
+
+	result, err := evaluator.EvaluateFormula(tsData)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should have 2 result series
+	assert.Equal(t, 2, len(result))
+
+	// Verify the complex calculation: A/B + C for the first series
+	for _, series := range result {
+		hasRunning := false
+		hasHost := false
+		for _, label := range series.Labels {
+			if label.Key.Name == "state" && label.Value == "running" {
+				hasRunning = true
+			}
+			if label.Key.Name == "host_name" {
+				hasHost = true
+			}
+		}
+
+		if hasRunning && hasHost {
+			// timestamp 1: 10/22 + 10 = 10.45454545454545
+			expectedVal1 := 10.0/22.0 + 10.0
+			assert.InDelta(t, expectedVal1, series.Values[0].Value, 0.0001)
+
+			// timestamp 2: 20/65 + 20 = 20.3076923076923077
+			expectedVal2 := 20.0/65.0 + 20.0
+			assert.InDelta(t, expectedVal2, series.Values[1].Value, 0.0001)
+		}
+	}
+}