Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

8.3 KB
Raw Blame
package queryparser

import (
	"bytes"
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"reflect"
	"sort"
	"strings"
	"testing"

	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
	"github.com/SigNoz/signoz/pkg/types/parsertypes"
	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
)

func TestAPI_AnalyzeQueryFilter(t *testing.T) {
	queryParser := New(instrumentationtest.New().ToProviderSettings())
	aH := NewAPI(instrumentationtest.New().ToProviderSettings(), queryParser)

	tests := []struct {
		name              string
		requestBody       parsertypes.QueryFilterAnalyzeRequest
		expectedStatus    int
		expectedStatusStr string
		expectedError     bool
		errorContains     string
		expectedMetrics   []string
		expectedGroups    []parsertypes.ColumnInfoResponse
	}{
		{
			name: "PromQL - Nested aggregation inside subquery",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     `max_over_time(sum(rate(cpu_usage_total[5m]))[1h:5m])`,
				QueryType: querybuildertypesv5.QueryTypePromQL,
			},
			expectedStatus:    http.StatusOK,
			expectedStatusStr: "success",
			expectedError:     false,
			expectedMetrics:   []string{"cpu_usage_total"},
			expectedGroups:    []parsertypes.ColumnInfoResponse{},
		},
		{
			name: "PromQL - Subquery with multiple metrics",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     `avg_over_time((foo + bar)[10m:1m])`,
				QueryType: querybuildertypesv5.QueryTypePromQL,
			},
			expectedStatus:    http.StatusOK,
			expectedStatusStr: "success",
			expectedError:     false,
			expectedMetrics:   []string{"bar", "foo"},
			expectedGroups:    []parsertypes.ColumnInfoResponse{},
		},
		{
			name: "PromQL - Simple meta-metric with grouping",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     `sum by (pod) (up)`,
				QueryType: querybuildertypesv5.QueryTypePromQL,
			},
			expectedStatus:    http.StatusOK,
			expectedStatusStr: "success",
			expectedError:     false,
			expectedMetrics:   []string{"up"},
			expectedGroups:    []parsertypes.ColumnInfoResponse{{Name: "pod", Alias: ""}},
		},
		{
			name: "ClickHouse - Simple CTE with GROUP BY",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query: `WITH aggregated AS (
					SELECT region as region_alias, sum(value) AS total
					FROM metrics
					WHERE metric_name = 'cpu_usage'
					GROUP BY region
				)
				SELECT * FROM aggregated`,
				QueryType: querybuildertypesv5.QueryTypeClickHouseSQL,
			},
			expectedStatus:    http.StatusOK,
			expectedStatusStr: "success",
			expectedError:     false,
			expectedMetrics:   []string{"cpu_usage"},
			expectedGroups:    []parsertypes.ColumnInfoResponse{{Name: "region", Alias: "region_alias"}},
		},
		{
			name: "ClickHouse - CTE chain with last GROUP BY + Alias should be returned if exists",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query: `WITH step1 AS (
					SELECT service as service_alias, timestamp as ts, value
					FROM metrics
					WHERE metric_name = 'requests'
					GROUP BY service, timestamp
				),
				step2 AS (
					SELECT ts, avg(value) AS avg_value
					FROM step1
					GROUP BY ts
				)
				SELECT * FROM step2`,
				QueryType: querybuildertypesv5.QueryTypeClickHouseSQL,
			},
			expectedStatus:    http.StatusOK,
			expectedStatusStr: "success",
			expectedError:     false,
			expectedMetrics:   []string{"requests"},
			expectedGroups:    []parsertypes.ColumnInfoResponse{{Name: "ts", Alias: ""}},
		},
		{
			name: "ClickHouse - Outer GROUP BY overrides CTE GROUP BY + Alias should be returned if exists",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query: `WITH cte AS (
					SELECT region, service, value
					FROM metrics
					WHERE metric_name = 'memory'
					GROUP BY region, service
				)
				SELECT region as region_alias, sum(value) as total
				FROM cte
				GROUP BY region`,
				QueryType: querybuildertypesv5.QueryTypeClickHouseSQL,
			},
			expectedStatus:    http.StatusOK,
			expectedStatusStr: "success",
			expectedError:     false,
			expectedMetrics:   []string{"memory"},
			expectedGroups:    []parsertypes.ColumnInfoResponse{{Name: "region", Alias: "region_alias"}},
		},
		{
			name: "ClickHouse - Invalid query should return error",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     `SELECT WHERE metric_name = 'memory' GROUP BY region, service`,
				QueryType: querybuildertypesv5.QueryTypeClickHouseSQL,
			},
			expectedStatus:    http.StatusBadRequest,
			expectedStatusStr: "error",
			expectedError:     true,
			errorContains:     "failed to parse clickhouse query",
		},
		{
			name: "Empty query should return error",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     "",
				QueryType: querybuildertypesv5.QueryTypePromQL,
			},
			expectedStatus:    http.StatusBadRequest,
			expectedStatusStr: "error",
			expectedError:     true,
			errorContains:     "query is required and cannot be empty",
		},
		{
			name: "Invalid queryType should return error",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     `sum(rate(cpu_usage[5m]))`,
				QueryType: querybuildertypesv5.QueryTypeUnknown,
			},
			expectedStatus:    http.StatusBadRequest,
			expectedStatusStr: "error",
			expectedError:     true,
			errorContains:     "unsupported queryType",
		},
		{
			name: "Invalid PromQL syntax should return error",
			requestBody: parsertypes.QueryFilterAnalyzeRequest{
				Query:     `sum by ((foo)(bar))(http_requests_total)`,
				QueryType: querybuildertypesv5.QueryTypePromQL,
			},
			expectedStatus:    http.StatusBadRequest,
			expectedStatusStr: "error",
			expectedError:     true,
			errorContains:     "failed to parse promql query",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Create request body
			reqBody, err := json.Marshal(tt.requestBody)
			if err != nil {
				t.Fatalf("failed to marshal request body: %v", err)
			}

			// Create HTTP request
			req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/v1/query_filter/analyze", bytes.NewBuffer(reqBody))
			req.Header.Set("Content-Type", "application/json")

			// Create response recorder
			rr := httptest.NewRecorder()

			// Call handler
			aH.AnalyzeQueryFilter(rr, req)

			// Check status code
			if rr.Code != tt.expectedStatus {
				t.Errorf("expected status %d, got %d", tt.expectedStatus, rr.Code)
			}

			// Parse response
			var resp map[string]interface{}
			if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
				t.Fatalf("failed to unmarshal response: %v, body: %s", err, rr.Body.String())
			}

			// Check status string
			if resp["status"] != tt.expectedStatusStr {
				t.Errorf("expected status '%s', got %v", tt.expectedStatusStr, resp["status"])
			}

			if tt.expectedError {
				errorObj, ok := resp["error"].(map[string]interface{})
				if !ok {
					t.Fatalf("expected error to be a map, got %T", resp["error"])
				}
				errorMsg, ok := errorObj["message"].(string)
				if !ok {
					t.Fatalf("expected error message to be a string, got %T", errorObj["message"])
				}
				if !strings.Contains(errorMsg, tt.errorContains) {
					t.Errorf("expected error message to contain '%s', got '%s'", tt.errorContains, errorMsg)
				}
			} else {
				// Validate success response
				data, ok := resp["data"].(map[string]interface{})
				if !ok {
					t.Fatalf("expected data to be a map, got %T", resp["data"])
				}

				// Marshal data back to JSON and unmarshal into QueryFilterAnalyzeResponse struct
				dataBytes, err := json.Marshal(data)
				if err != nil {
					t.Fatalf("failed to marshal data: %v", err)
				}

				var responseData parsertypes.QueryFilterAnalyzeResponse
				if err := json.Unmarshal(dataBytes, &responseData); err != nil {
					t.Fatalf("failed to unmarshal data into QueryFilterAnalyzeResponse: %v", err)
				}

				// Sort the arrays for comparison
				gotMetrics := make([]string, len(responseData.MetricNames))
				copy(gotMetrics, responseData.MetricNames)
				sort.Strings(gotMetrics)

				gotGroups := make([]parsertypes.ColumnInfoResponse, len(responseData.Groups))
				copy(gotGroups, responseData.Groups)

				// Compare using deep equal
				if !reflect.DeepEqual(gotMetrics, tt.expectedMetrics) {
					t.Errorf("expected metricNames %v, got %v", tt.expectedMetrics, gotMetrics)
				}
				if !reflect.DeepEqual(gotGroups, tt.expectedGroups) {
					t.Errorf("expected groups %v, got %v", tt.expectedGroups, gotGroups)
				}
			}
		})
	}
}