chore(frontend): sync pylon chat widget theme with app theme (#10830)

frontend/src/AppRoutes/index.tsx

@@ -18,7 +18,7 @@ import AppLayout from 'container/AppLayout';
 import Hex from 'crypto-js/enc-hex';
 import HmacSHA256 from 'crypto-js/hmac-sha256';
 import { KeyboardHotkeysProvider } from 'hooks/hotkeys/useKeyboardHotkeys';
-import { useThemeConfig } from 'hooks/useDarkMode';
+import { useIsDarkMode, useThemeConfig } from 'hooks/useDarkMode';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { NotificationProvider } from 'hooks/useNotifications';
 import { ResourceProvider } from 'hooks/useResourceAttribute';
@@ -212,6 +212,12 @@ function App(): JSX.Element {
 		activeLicenseFetchError,
 	]);
 
+	const isDarkMode = useIsDarkMode();
+
+	useEffect(() => {
+		window.Pylon?.('setTheme', isDarkMode ? 'dark' : 'light');
+	}, [isDarkMode]);
+
 	useEffect(() => {
 		if (
 			pathname === ROUTES.ONBOARDING ||

pkg/querier/postprocess.go

@@ -124,12 +124,8 @@ func (q *querier) postProcessResults(ctx context.Context, results map[string]any
 				continue
 			}
 
-			stepInterval, err := req.StepIntervalForQuery(name)
-			if err != nil {
-				return nil, err
-			}
 			funcs := []qbtypes.Function{{Name: qbtypes.FunctionNameFillZero}}
-			funcs = q.prepareFillZeroArgsWithStep(funcs, req, stepInterval)
+			funcs = q.prepareFillZeroArgsWithStep(funcs, req, req.StepIntervalForQuery(name))
 			// empty time series if it doesn't exist
 			tsData, ok := typedResults[name].Value.(*qbtypes.TimeSeriesData)
 			if !ok {

pkg/query-service/postprocess/having.go

@@ -14,11 +14,10 @@ func ApplyHavingClause(result []*v3.Result, queryRangeParams *v3.QueryRangeParam
 		builderQueries := queryRangeParams.CompositeQuery.BuilderQueries
 
 		// apply having clause for metrics and formula
-		builderQuery := builderQueries[result.QueryName]
-		if builderQuery != nil &&
-			(builderQuery.DataSource == v3.DataSourceMetrics ||
-				builderQuery.QueryName != builderQuery.Expression) {
-			havingClause := builderQuery.Having
+		if builderQueries != nil &&
+			(builderQueries[result.QueryName].DataSource == v3.DataSourceMetrics ||
+				builderQueries[result.QueryName].QueryName != builderQueries[result.QueryName].Expression) {
+			havingClause := builderQueries[result.QueryName].Having
 
 			for i := 0; i < len(result.Series); i++ {
 				for j := 0; j < len(result.Series[i].Points); j++ {

pkg/query-service/postprocess/having_test.go

@@ -312,72 +312,6 @@ func TestApplyHavingCaluse(t *testing.T) {
 				},
 			},
 		},
-		{
-			name: "query not in builder queries should not panic",
-			results: []*v3.Result{
-				{
-					QueryName: "A",
-					Series: []*v3.Series{
-						{
-							Points: []v3.Point{
-								{Value: 1.0},
-								{Value: 2.0},
-							},
-						},
-					},
-				},
-			},
-			params: &v3.QueryRangeParamsV3{
-				CompositeQuery: &v3.CompositeQuery{
-					BuilderQueries: map[string]*v3.BuilderQuery{},
-				},
-			},
-			want: []*v3.Result{
-				{
-					QueryName: "A",
-					Series: []*v3.Series{
-						{
-							Points: []v3.Point{
-								{Value: 1.0},
-								{Value: 2.0},
-							},
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "nil builder queries should not panic",
-			results: []*v3.Result{
-				{
-					QueryName: "A",
-					Series: []*v3.Series{
-						{
-							Points: []v3.Point{
-								{Value: 1.0},
-							},
-						},
-					},
-				},
-			},
-			params: &v3.QueryRangeParamsV3{
-				CompositeQuery: &v3.CompositeQuery{
-					BuilderQueries: nil,
-				},
-			},
-			want: []*v3.Result{
-				{
-					QueryName: "A",
-					Series: []*v3.Series{
-						{
-							Points: []v3.Point{
-								{Value: 1.0},
-							},
-						},
-					},
-				},
-			},
-		},
 	}
 
 	for _, tc := range testCases {

pkg/queryparser/queryfilterextractor/clickhouse_originparser.go

@@ -104,15 +104,8 @@ func extractCHOriginFieldFromQuery(query string) (string, error) {
 		return "", errors.NewInternalf(errors.CodeInternal, "failed to parse origin field from query: %s", err.Error())
 	}
 
-	if len(stmts) == 0 {
-		return "", errors.NewInternalf(errors.CodeInternal, "no statements found in query")
-	}
-
 	// Get the first statement which should be a SELECT
-	selectStmt, ok := stmts[0].(*parser.SelectQuery)
-	if !ok {
-		return "", errors.NewInternalf(errors.CodeInternal, "expected SELECT query, got %T", stmts[0])
-	}
+	selectStmt := stmts[0].(*parser.SelectQuery)
 
 	// If query has multiple select items, return blank string as we don't expect multiple select items
 	if len(selectStmt.SelectItems) > 1 {

pkg/queryparser/queryparserimpl.go

@@ -2,7 +2,6 @@ package queryparser
 
 import (
 	"context"
-	"fmt"
 
 	"strings"
 
@@ -24,15 +23,7 @@ func New(settings factory.ProviderSettings) QueryParser {
 	}
 }
 
-func (p *queryParserImpl) AnalyzeQueryFilter(ctx context.Context, queryType qbtypes.QueryType, query string) (result *queryfilterextractor.FilterResult, err error) {
-	// the third-party clickhouse sql parser can panic on certain inputs, recover gracefully
-	defer func() {
-		if r := recover(); r != nil {
-			result = nil
-			err = errors.NewInternalf(errors.CodeInternal, "failed to analyze query filter: %s", fmt.Sprint(r))
-		}
-	}()
-
+func (p *queryParserImpl) AnalyzeQueryFilter(ctx context.Context, queryType qbtypes.QueryType, query string) (*queryfilterextractor.FilterResult, error) {
 	var extractorType queryfilterextractor.ExtractorType
 	switch queryType {
 	case qbtypes.QueryTypePromQL:

pkg/types/querybuildertypes/querybuildertypesv5/formula.go

@@ -91,16 +91,6 @@ func (f QueryBuilderFormula) Validate() error {
 		)
 	}
 
-	// Validate expression is parseable
-	if _, err := govaluate.NewEvaluableExpressionWithFunctions(f.Expression, EvalFuncs()); err != nil {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"failed to parse expression for formula query %q: %s",
-			f.Name,
-			err.Error(),
-		)
-	}
-
 	// Validate functions if present
 	for i, fn := range f.Functions {
 		if err := fn.Validate(); err != nil {

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -305,7 +305,7 @@ func (q *QueryRangeRequest) PrepareJSONSchema(schema *jsonschema.Schema) error {
 	return nil
 }
 
-func (r *QueryRangeRequest) StepIntervalForQuery(name string) (int64, error) {
+func (r *QueryRangeRequest) StepIntervalForQuery(name string) int64 {
 	stepsMap := make(map[string]int64)
 	for _, query := range r.CompositeQuery.Queries {
 		switch spec := query.Spec.(type) {
@@ -317,13 +317,11 @@ func (r *QueryRangeRequest) StepIntervalForQuery(name string) (int64, error) {
 			stepsMap[spec.Name] = spec.StepInterval.Milliseconds()
 		case PromQuery:
 			stepsMap[spec.Name] = spec.Step.Milliseconds()
-		case QueryBuilderTraceOperator:
-			stepsMap[spec.Name] = spec.StepInterval.Milliseconds()
 		}
 	}
 
 	if step, ok := stepsMap[name]; ok {
-		return step, nil
+		return step
 	}
 
 	exprStr := ""
@@ -337,15 +335,12 @@ func (r *QueryRangeRequest) StepIntervalForQuery(name string) (int64, error) {
 		}
 	}
 
-	expression, err := govaluate.NewEvaluableExpressionWithFunctions(exprStr, EvalFuncs())
-	if err != nil {
-		return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to parse expression for formula query %q: %s", name, err.Error())
-	}
+	expression, _ := govaluate.NewEvaluableExpressionWithFunctions(exprStr, EvalFuncs())
 	steps := []int64{}
 	for _, v := range expression.Vars() {
 		steps = append(steps, stepsMap[v])
 	}
-	return LCMList(steps), nil
+	return LCMList(steps)
 }
 
 func (r *QueryRangeRequest) NumAggregationForQuery(name string) int64 {

pkg/types/querybuildertypes/querybuildertypesv5/req_test.go

@@ -1798,108 +1798,3 @@ func TestQueryRangeRequest_GetQueriesSupportingZeroDefault(t *testing.T) {
 		})
 	}
 }
-
-func TestQueryRangeRequest_StepIntervalForQuery(t *testing.T) {
-	tests := []struct {
-		name      string
-		request   QueryRangeRequest
-		queryName string
-		wantStep  int64
-		wantErr   bool
-	}{
-		{
-			name: "trace operator returns its step interval",
-			request: QueryRangeRequest{
-				CompositeQuery: CompositeQuery{
-					Queries: []QueryEnvelope{
-						{
-							Type: QueryTypeBuilder,
-							Spec: QueryBuilderQuery[TraceAggregation]{
-								Name:         "A",
-								Signal:       telemetrytypes.SignalTraces,
-								StepInterval: Step{Duration: 60 * time.Second},
-								Aggregations: []TraceAggregation{{Expression: "count()"}},
-							},
-						},
-						{
-							Type: QueryTypeTraceOperator,
-							Spec: QueryBuilderTraceOperator{
-								Name:         "Trace Operator",
-								StepInterval: Step{Duration: 120 * time.Second},
-								Expression:   "A",
-							},
-						},
-					},
-				},
-			},
-			queryName: "Trace Operator",
-			wantStep:  120000,
-		},
-		{
-			name: "formula computes LCM of referenced query steps",
-			request: QueryRangeRequest{
-				CompositeQuery: CompositeQuery{
-					Queries: []QueryEnvelope{
-						{
-							Type: QueryTypeBuilder,
-							Spec: QueryBuilderQuery[TraceAggregation]{
-								Name:         "A",
-								Signal:       telemetrytypes.SignalTraces,
-								StepInterval: Step{Duration: 60 * time.Second},
-								Aggregations: []TraceAggregation{{Expression: "count()"}},
-							},
-						},
-						{
-							Type: QueryTypeBuilder,
-							Spec: QueryBuilderQuery[TraceAggregation]{
-								Name:         "B",
-								Signal:       telemetrytypes.SignalTraces,
-								StepInterval: Step{Duration: 90 * time.Second},
-								Aggregations: []TraceAggregation{{Expression: "count()"}},
-							},
-						},
-						{
-							Type: QueryTypeFormula,
-							Spec: QueryBuilderFormula{
-								Name:       "F1",
-								Expression: "A + B",
-							},
-						},
-					},
-				},
-			},
-			queryName: "F1",
-			wantStep:  180000, // LCM of 60s and 90s = 180s
-		},
-		{
-			name: "invalid formula expression returns error",
-			request: QueryRangeRequest{
-				CompositeQuery: CompositeQuery{
-					Queries: []QueryEnvelope{
-						{
-							Type: QueryTypeFormula,
-							Spec: QueryBuilderFormula{
-								Name:       "F1",
-								Expression: "A +",
-							},
-						},
-					},
-				},
-			},
-			queryName: "F1",
-			wantErr:   true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.request.StepIntervalForQuery(tt.queryName)
-			if tt.wantErr {
-				require.Error(t, err)
-				return
-			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.wantStep, got)
-		})
-	}
-}

pkg/types/querybuildertypes/querybuildertypesv5/validation.go

@@ -496,19 +496,6 @@ func (r *QueryRangeRequest) Validate(opts ...ValidationOption) error {
 		)
 	}
 
-	// raw/trace request types don't support metric queries;
-	// metrics are always aggregated and there is no raw form.
-	if r.RequestType == RequestTypeRaw || r.RequestType == RequestTypeRawStream || r.RequestType == RequestTypeTrace {
-		for _, envelope := range r.CompositeQuery.Queries {
-			if envelope.GetSignal() == telemetrytypes.SignalMetrics {
-				return errors.NewInvalidInputf(
-					errors.CodeInvalidInput,
-					"raw request type is not supported for metric queries",
-				)
-			}
-		}
-	}
-
 	// Validate composite query
 	if err := r.CompositeQuery.Validate(opts...); err != nil {
 		return err
@@ -597,7 +584,13 @@ func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) err
 				"invalid formula spec",
 			)
 		}
-		return spec.Validate()
+		if spec.Expression == "" {
+			return errors.NewInvalidInputf(
+				errors.CodeInvalidInput,
+				"formula expression is required",
+			)
+		}
+		return nil
 	case QueryTypeJoin:
 		_, ok := envelope.Spec.(QueryBuilderJoin)
 		if !ok {

pkg/types/querybuildertypes/querybuildertypesv5/validation_test.go

@@ -518,7 +518,7 @@ func TestQueryRangeRequest_ValidateCompositeQuery(t *testing.T) {
 				},
 			},
 			wantErr: true,
-			errMsg:  "expression cannot be blank",
+			errMsg:  "expression is required",
 		},
 		{
 			name: "promql with empty query should return error",
@@ -665,57 +665,6 @@ func TestQueryRangeRequest_ValidateCompositeQuery(t *testing.T) {
 			},
 			wantErr: false,
 		},
-		{
-			name: "raw request with metric query should return error",
-			request: QueryRangeRequest{
-				Start:       1640995200000,
-				End:         1640998800000,
-				RequestType: RequestTypeRaw,
-				CompositeQuery: CompositeQuery{
-					Queries: []QueryEnvelope{
-						{
-							Type: QueryTypeBuilder,
-							Spec: QueryBuilderQuery[MetricAggregation]{
-								Name:         "A",
-								Disabled:     true,
-								Signal:       telemetrytypes.SignalMetrics,
-								Aggregations: []MetricAggregation{},
-							},
-						},
-						{
-							Type: QueryTypeFormula,
-							Spec: QueryBuilderFormula{
-								Name:       "F1",
-								Expression: "A",
-							},
-						},
-					},
-				},
-			},
-			wantErr: true,
-			errMsg:  "raw request type is not supported for metric queries",
-		},
-		{
-			name: "raw request with log query without aggregations should pass",
-			request: QueryRangeRequest{
-				Start:       1640995200000,
-				End:         1640998800000,
-				RequestType: RequestTypeRaw,
-				CompositeQuery: CompositeQuery{
-					Queries: []QueryEnvelope{
-						{
-							Type: QueryTypeBuilder,
-							Spec: QueryBuilderQuery[LogAggregation]{
-								Name:         "A",
-								Signal:       telemetrytypes.SignalLogs,
-								Aggregations: []LogAggregation{},
-							},
-						},
-					},
-				},
-			},
-			wantErr: false,
-		},
 	}
 
 	for _, tt := range tests {
@@ -784,7 +733,7 @@ func TestValidateQueryEnvelope(t *testing.T) {
 			},
 			requestType: RequestTypeTimeSeries,
 			wantErr:     true,
-			errMsg:      "expression cannot be blank",
+			errMsg:      "expression is required",
 		},
 		{
 			name: "valid join spec",