@@ -365,10 +366,21 @@ curl -sL https://github.com/SigNoz/signoz/raw/develop/sample-apps/hotrod/hotrod- | HOTROD_NAMESPACE=sample-application bash ``` - **[`^top^`](#)** + **[`^top^`](#contributing-guidelines)** --- +# 6. Contribute to Dashboards 📈 + +**Need to Update: [https://github.com/SigNoz/dashboards](https://github.com/SigNoz/dashboards)** + +To contribute a new dashboard template for any service, follow the contribution guidelines in the [Dashboard Contributing Guide](https://github.com/SigNoz/dashboards/blob/main/CONTRIBUTING.md). In brief: + +1. Create a dashboard JSON file. +2. Add a README file explaining the dashboard, the metrics ingested, and the configurations needed. +3. Include screenshots of the dashboard in the `assets/` directory. +4. Submit a pull request for review. + ## Other Ways to Contribute There are many other ways to get involved with the community and to participate in this project: @@ -379,7 +391,6 @@ There are many other ways to get involved with the community and to participate - Help answer questions on forums such as Stack Overflow and [SigNoz Community Slack Channel](https://signoz.io/slack). - Tell others about the project on Twitter, your blog, etc. - Again, Feel free to ping us on [`#contributing`](https://signoz-community.slack.com/archives/C01LWQ8KS7M) or [`#contributing-frontend`](https://signoz-community.slack.com/archives/C027134DM8B) on our slack community if you need any help on this :) Thank You! diff --git a/ee/query-service/anomaly/daily.go b/ee/query-service/anomaly/daily.go new file mode 100644 index 0000000000..bbafe1618e --- /dev/null +++ b/ee/query-service/anomaly/daily.go @@ -0,0 +1,44 @@ +package anomaly + +import ( + "context" + + querierV2 "go.signoz.io/signoz/pkg/query-service/app/querier/v2" + "go.signoz.io/signoz/pkg/query-service/app/queryBuilder" +) + +type DailyProvider struct { + BaseSeasonalProvider +} + +var _ BaseProvider = (*DailyProvider)(nil) + +func (dp *DailyProvider) GetBaseSeasonalProvider() *BaseSeasonalProvider { + return &dp.BaseSeasonalProvider +} + +// NewDailyProvider uses the same generic option type +func NewDailyProvider(opts ...GenericProviderOption[*DailyProvider]) *DailyProvider { + dp := &DailyProvider{ + BaseSeasonalProvider: BaseSeasonalProvider{}, + } + + for _, opt := range opts { + opt(dp) + } + + dp.querierV2 = querierV2.NewQuerier(querierV2.QuerierOptions{ + Reader: dp.reader, + Cache: dp.cache, + KeyGenerator: queryBuilder.NewKeyGenerator(), + FluxInterval: dp.fluxInterval, + FeatureLookup: dp.ff, + }) + + return dp +} + +func (p *DailyProvider) GetAnomalies(ctx context.Context, req *GetAnomaliesRequest) (*GetAnomaliesResponse, error) { + req.Seasonality = SeasonalityDaily + return p.getAnomalies(ctx, req) +} diff --git a/ee/query-service/anomaly/hourly.go b/ee/query-service/anomaly/hourly.go new file mode 100644 index 0000000000..1ee08655f0 --- /dev/null +++ b/ee/query-service/anomaly/hourly.go @@ -0,0 +1,44 @@ +package anomaly + +import ( + "context" + + querierV2 "go.signoz.io/signoz/pkg/query-service/app/querier/v2" + "go.signoz.io/signoz/pkg/query-service/app/queryBuilder" +) + +type HourlyProvider struct { + BaseSeasonalProvider +} + +var _ BaseProvider = (*HourlyProvider)(nil) + +func (hp *HourlyProvider) GetBaseSeasonalProvider() *BaseSeasonalProvider { + return &hp.BaseSeasonalProvider +} + +// NewHourlyProvider now uses the generic option type +func NewHourlyProvider(opts ...GenericProviderOption[*HourlyProvider]) *HourlyProvider { + hp := &HourlyProvider{ + BaseSeasonalProvider: BaseSeasonalProvider{}, + } + + for _, opt := range opts { + opt(hp) + } + + hp.querierV2 = querierV2.NewQuerier(querierV2.QuerierOptions{ + Reader: hp.reader, + Cache: hp.cache, + KeyGenerator: queryBuilder.NewKeyGenerator(), + FluxInterval: hp.fluxInterval, + FeatureLookup: hp.ff, + }) + + return hp +} + +func (p *HourlyProvider) GetAnomalies(ctx context.Context, req *GetAnomaliesRequest) (*GetAnomaliesResponse, error) { + req.Seasonality = SeasonalityHourly + return p.getAnomalies(ctx, req) +} diff --git a/ee/query-service/anomaly/params.go b/ee/query-service/anomaly/params.go new file mode 100644 index 0000000000..8340a2673a --- /dev/null +++ b/ee/query-service/anomaly/params.go @@ -0,0 +1,248 @@ +package anomaly + +import ( + "math" + "time" + + "go.signoz.io/signoz/pkg/query-service/common" + v3 "go.signoz.io/signoz/pkg/query-service/model/v3" +) + +type Seasonality string + +const ( + SeasonalityHourly Seasonality = "hourly" + SeasonalityDaily Seasonality = "daily" + SeasonalityWeekly Seasonality = "weekly" +) + +func (s Seasonality) String() string { + return string(s) +} + +var ( + oneWeekOffset = 24 * 7 * time.Hour.Milliseconds() + oneDayOffset = 24 * time.Hour.Milliseconds() + oneHourOffset = time.Hour.Milliseconds() + fiveMinOffset = 5 * time.Minute.Milliseconds() +) + +func (s Seasonality) IsValid() bool { + switch s { + case SeasonalityHourly, SeasonalityDaily, SeasonalityWeekly: + return true + default: + return false + } +} + +type GetAnomaliesRequest struct { + Params *v3.QueryRangeParamsV3 + Seasonality Seasonality +} + +type GetAnomaliesResponse struct { + Results []*v3.Result +} + +// anomalyParams is the params for anomaly detection +// prediction = avg(past_period_query) + avg(current_season_query) - mean(past_season_query, past2_season_query, past3_season_query) +// +// ^ ^ +// | | +// (rounded value for past peiod) + (seasonal growth) +// +// score = abs(value - prediction) / stddev (current_season_query) +type anomalyQueryParams struct { + // CurrentPeriodQuery is the query range params for period user is looking at or eval window + // Example: (now-5m, now), (now-30m, now), (now-1h, now) + // The results obtained from this query are used to compare with predicted values + // and to detect anomalies + CurrentPeriodQuery *v3.QueryRangeParamsV3 + // PastPeriodQuery is the query range params for past seasonal period + // Example: For weekly seasonality, (now-1w-5m, now-1w) + // : For daily seasonality, (now-1d-5m, now-1d) + // : For hourly seasonality, (now-1h-5m, now-1h) + PastPeriodQuery *v3.QueryRangeParamsV3 + // CurrentSeasonQuery is the query range params for current period (seasonal) + // Example: For weekly seasonality, this is the query range params for the (now-1w-5m, now) + // : For daily seasonality, this is the query range params for the (now-1d-5m, now) + // : For hourly seasonality, this is the query range params for the (now-1h-5m, now) + CurrentSeasonQuery *v3.QueryRangeParamsV3 + // PastSeasonQuery is the query range params for past seasonal period to the current season + // Example: For weekly seasonality, this is the query range params for the (now-2w-5m, now-1w) + // : For daily seasonality, this is the query range params for the (now-2d-5m, now-1d) + // : For hourly seasonality, this is the query range params for the (now-2h-5m, now-1h) + PastSeasonQuery *v3.QueryRangeParamsV3 + + // Past2SeasonQuery is the query range params for past 2 seasonal period to the current season + // Example: For weekly seasonality, this is the query range params for the (now-3w-5m, now-2w) + // : For daily seasonality, this is the query range params for the (now-3d-5m, now-2d) + // : For hourly seasonality, this is the query range params for the (now-3h-5m, now-2h) + Past2SeasonQuery *v3.QueryRangeParamsV3 + // Past3SeasonQuery is the query range params for past 3 seasonal period to the current season + // Example: For weekly seasonality, this is the query range params for the (now-4w-5m, now-3w) + // : For daily seasonality, this is the query range params for the (now-4d-5m, now-3d) + // : For hourly seasonality, this is the query range params for the (now-4h-5m, now-3h) + Past3SeasonQuery *v3.QueryRangeParamsV3 +} + +func updateStepInterval(req *v3.QueryRangeParamsV3) { + start := req.Start + end := req.End + + req.Step = int64(math.Max(float64(common.MinAllowedStepInterval(start, end)), 60)) + for _, q := range req.CompositeQuery.BuilderQueries { + // If the step interval is less than the minimum allowed step interval, set it to the minimum allowed step interval + if minStep := common.MinAllowedStepInterval(start, end); q.StepInterval < minStep { + q.StepInterval = minStep + } + } +} + +func prepareAnomalyQueryParams(req *v3.QueryRangeParamsV3, seasonality Seasonality) *anomalyQueryParams { + start := req.Start + end := req.End + + currentPeriodQuery := &v3.QueryRangeParamsV3{ + Start: start, + End: end, + CompositeQuery: req.CompositeQuery.Clone(), + Variables: make(map[string]interface{}, 0), + NoCache: false, + } + updateStepInterval(currentPeriodQuery) + + var pastPeriodStart, pastPeriodEnd int64 + + switch seasonality { + // for one week period, we fetch the data from the past week with 5 min offset + case SeasonalityWeekly: + pastPeriodStart = start - oneWeekOffset - fiveMinOffset + pastPeriodEnd = end - oneWeekOffset + // for one day period, we fetch the data from the past day with 5 min offset + case SeasonalityDaily: + pastPeriodStart = start - oneDayOffset - fiveMinOffset + pastPeriodEnd = end - oneDayOffset + // for one hour period, we fetch the data from the past hour with 5 min offset + case SeasonalityHourly: + pastPeriodStart = start - oneHourOffset - fiveMinOffset + pastPeriodEnd = end - oneHourOffset + } + + pastPeriodQuery := &v3.QueryRangeParamsV3{ + Start: pastPeriodStart, + End: pastPeriodEnd, + CompositeQuery: req.CompositeQuery.Clone(), + Variables: make(map[string]interface{}, 0), + NoCache: false, + } + updateStepInterval(pastPeriodQuery) + + // seasonality growth trend + var currentGrowthPeriodStart, currentGrowthPeriodEnd int64 + switch seasonality { + case SeasonalityWeekly: + currentGrowthPeriodStart = start - oneWeekOffset + currentGrowthPeriodEnd = end + case SeasonalityDaily: + currentGrowthPeriodStart = start - oneDayOffset + currentGrowthPeriodEnd = end + case SeasonalityHourly: + currentGrowthPeriodStart = start - oneHourOffset + currentGrowthPeriodEnd = end + } + + currentGrowthQuery := &v3.QueryRangeParamsV3{ + Start: currentGrowthPeriodStart, + End: currentGrowthPeriodEnd, + CompositeQuery: req.CompositeQuery.Clone(), + Variables: make(map[string]interface{}, 0), + NoCache: false, + } + updateStepInterval(currentGrowthQuery) + + var pastGrowthPeriodStart, pastGrowthPeriodEnd int64 + switch seasonality { + case SeasonalityWeekly: + pastGrowthPeriodStart = start - 2*oneWeekOffset + pastGrowthPeriodEnd = start - 1*oneWeekOffset + case SeasonalityDaily: + pastGrowthPeriodStart = start - 2*oneDayOffset + pastGrowthPeriodEnd = start - 1*oneDayOffset + case SeasonalityHourly: + pastGrowthPeriodStart = start - 2*oneHourOffset + pastGrowthPeriodEnd = start - 1*oneHourOffset + } + + pastGrowthQuery := &v3.QueryRangeParamsV3{ + Start: pastGrowthPeriodStart, + End: pastGrowthPeriodEnd, + CompositeQuery: req.CompositeQuery.Clone(), + Variables: make(map[string]interface{}, 0), + NoCache: false, + } + updateStepInterval(pastGrowthQuery) + + var past2GrowthPeriodStart, past2GrowthPeriodEnd int64 + switch seasonality { + case SeasonalityWeekly: + past2GrowthPeriodStart = start - 3*oneWeekOffset + past2GrowthPeriodEnd = start - 2*oneWeekOffset + case SeasonalityDaily: + past2GrowthPeriodStart = start - 3*oneDayOffset + past2GrowthPeriodEnd = start - 2*oneDayOffset + case SeasonalityHourly: + past2GrowthPeriodStart = start - 3*oneHourOffset + past2GrowthPeriodEnd = start - 2*oneHourOffset + } + + past2GrowthQuery := &v3.QueryRangeParamsV3{ + Start: past2GrowthPeriodStart, + End: past2GrowthPeriodEnd, + CompositeQuery: req.CompositeQuery.Clone(), + Variables: make(map[string]interface{}, 0), + NoCache: false, + } + updateStepInterval(past2GrowthQuery) + + var past3GrowthPeriodStart, past3GrowthPeriodEnd int64 + switch seasonality { + case SeasonalityWeekly: + past3GrowthPeriodStart = start - 4*oneWeekOffset + past3GrowthPeriodEnd = start - 3*oneWeekOffset + case SeasonalityDaily: + past3GrowthPeriodStart = start - 4*oneDayOffset + past3GrowthPeriodEnd = start - 3*oneDayOffset + case SeasonalityHourly: + past3GrowthPeriodStart = start - 4*oneHourOffset + past3GrowthPeriodEnd = start - 3*oneHourOffset + } + + past3GrowthQuery := &v3.QueryRangeParamsV3{ + Start: past3GrowthPeriodStart, + End: past3GrowthPeriodEnd, + CompositeQuery: req.CompositeQuery.Clone(), + Variables: make(map[string]interface{}, 0), + NoCache: false, + } + updateStepInterval(past3GrowthQuery) + + return &anomalyQueryParams{ + CurrentPeriodQuery: currentPeriodQuery, + PastPeriodQuery: pastPeriodQuery, + CurrentSeasonQuery: currentGrowthQuery, + PastSeasonQuery: pastGrowthQuery, + Past2SeasonQuery: past2GrowthQuery, + Past3SeasonQuery: past3GrowthQuery, + } +} + +type anomalyQueryResults struct { + CurrentPeriodResults []*v3.Result + PastPeriodResults []*v3.Result + CurrentSeasonResults []*v3.Result + PastSeasonResults []*v3.Result + Past2SeasonResults []*v3.Result + Past3SeasonResults []*v3.Result +} diff --git a/ee/query-service/anomaly/provider.go b/ee/query-service/anomaly/provider.go new file mode 100644 index 0000000000..6e0f7a8cd0 --- /dev/null +++ b/ee/query-service/anomaly/provider.go @@ -0,0 +1,9 @@ +package anomaly + +import ( + "context" +) + +type Provider interface { + GetAnomalies(ctx context.Context, req *GetAnomaliesRequest) (*GetAnomaliesResponse, error) +} diff --git a/ee/query-service/anomaly/seasonal.go b/ee/query-service/anomaly/seasonal.go new file mode 100644 index 0000000000..9b5f33d3df --- /dev/null +++ b/ee/query-service/anomaly/seasonal.go @@ -0,0 +1,466 @@ +package anomaly + +import ( + "context" + "math" + "time" + + "go.signoz.io/signoz/pkg/query-service/cache" + "go.signoz.io/signoz/pkg/query-service/interfaces" + v3 "go.signoz.io/signoz/pkg/query-service/model/v3" + "go.signoz.io/signoz/pkg/query-service/postprocess" + "go.signoz.io/signoz/pkg/query-service/utils/labels" + "go.uber.org/zap" +) + +var ( + // TODO(srikanthccv): make this configurable? + movingAvgWindowSize = 7 +) + +// BaseProvider is an interface that includes common methods for all provider types +type BaseProvider interface { + GetBaseSeasonalProvider() *BaseSeasonalProvider +} + +// GenericProviderOption is a generic type for provider options +type GenericProviderOption[T BaseProvider] func(T) + +func WithCache[T BaseProvider](cache cache.Cache) GenericProviderOption[T] { + return func(p T) { + p.GetBaseSeasonalProvider().cache = cache + } +} + +func WithKeyGenerator[T BaseProvider](keyGenerator cache.KeyGenerator) GenericProviderOption[T] { + return func(p T) { + p.GetBaseSeasonalProvider().keyGenerator = keyGenerator + } +} + +func WithFeatureLookup[T BaseProvider](ff interfaces.FeatureLookup) GenericProviderOption[T] { + return func(p T) { + p.GetBaseSeasonalProvider().ff = ff + } +} + +func WithReader[T BaseProvider](reader interfaces.Reader) GenericProviderOption[T] { + return func(p T) { + p.GetBaseSeasonalProvider().reader = reader + } +} + +type BaseSeasonalProvider struct { + querierV2 interfaces.Querier + reader interfaces.Reader + fluxInterval time.Duration + cache cache.Cache + keyGenerator cache.KeyGenerator + ff interfaces.FeatureLookup +} + +func (p *BaseSeasonalProvider) getQueryParams(req *GetAnomaliesRequest) *anomalyQueryParams { + if !req.Seasonality.IsValid() { + req.Seasonality = SeasonalityDaily + } + return prepareAnomalyQueryParams(req.Params, req.Seasonality) +} + +func (p *BaseSeasonalProvider) getResults(ctx context.Context, params *anomalyQueryParams) (*anomalyQueryResults, error) { + zap.L().Info("fetching results for current period", zap.Any("currentPeriodQuery", params.CurrentPeriodQuery)) + currentPeriodResults, _, err := p.querierV2.QueryRange(ctx, params.CurrentPeriodQuery) + if err != nil { + return nil, err + } + + currentPeriodResults, err = postprocess.PostProcessResult(currentPeriodResults, params.CurrentPeriodQuery) + if err != nil { + return nil, err + } + + zap.L().Info("fetching results for past period", zap.Any("pastPeriodQuery", params.PastPeriodQuery)) + pastPeriodResults, _, err := p.querierV2.QueryRange(ctx, params.PastPeriodQuery) + if err != nil { + return nil, err + } + + pastPeriodResults, err = postprocess.PostProcessResult(pastPeriodResults, params.PastPeriodQuery) + if err != nil { + return nil, err + } + + zap.L().Info("fetching results for current season", zap.Any("currentSeasonQuery", params.CurrentSeasonQuery)) + currentSeasonResults, _, err := p.querierV2.QueryRange(ctx, params.CurrentSeasonQuery) + if err != nil { + return nil, err + } + + currentSeasonResults, err = postprocess.PostProcessResult(currentSeasonResults, params.CurrentSeasonQuery) + if err != nil { + return nil, err + } + + zap.L().Info("fetching results for past season", zap.Any("pastSeasonQuery", params.PastSeasonQuery)) + pastSeasonResults, _, err := p.querierV2.QueryRange(ctx, params.PastSeasonQuery) + if err != nil { + return nil, err + } + + pastSeasonResults, err = postprocess.PostProcessResult(pastSeasonResults, params.PastSeasonQuery) + if err != nil { + return nil, err + } + + zap.L().Info("fetching results for past 2 season", zap.Any("past2SeasonQuery", params.Past2SeasonQuery)) + past2SeasonResults, _, err := p.querierV2.QueryRange(ctx, params.Past2SeasonQuery) + if err != nil { + return nil, err + } + + past2SeasonResults, err = postprocess.PostProcessResult(past2SeasonResults, params.Past2SeasonQuery) + if err != nil { + return nil, err + } + + zap.L().Info("fetching results for past 3 season", zap.Any("past3SeasonQuery", params.Past3SeasonQuery)) + past3SeasonResults, _, err := p.querierV2.QueryRange(ctx, params.Past3SeasonQuery) + if err != nil { + return nil, err + } + + past3SeasonResults, err = postprocess.PostProcessResult(past3SeasonResults, params.Past3SeasonQuery) + if err != nil { + return nil, err + } + + return &anomalyQueryResults{ + CurrentPeriodResults: currentPeriodResults, + PastPeriodResults: pastPeriodResults, + CurrentSeasonResults: currentSeasonResults, + PastSeasonResults: pastSeasonResults, + Past2SeasonResults: past2SeasonResults, + Past3SeasonResults: past3SeasonResults, + }, nil +} + +// getMatchingSeries gets the matching series from the query result +// for the given series +func (p *BaseSeasonalProvider) getMatchingSeries(queryResult *v3.Result, series *v3.Series) *v3.Series { + if queryResult == nil || len(queryResult.Series) == 0 { + return nil + } + + for _, curr := range queryResult.Series { + currLabels := labels.FromMap(curr.Labels) + seriesLabels := labels.FromMap(series.Labels) + if currLabels.Hash() == seriesLabels.Hash() { + return curr + } + } + return nil +} + +func (p *BaseSeasonalProvider) getAvg(series *v3.Series) float64 { + if series == nil || len(series.Points) == 0 { + return 0 + } + var sum float64 + for _, smpl := range series.Points { + sum += smpl.Value + } + return sum / float64(len(series.Points)) +} + +func (p *BaseSeasonalProvider) getStdDev(series *v3.Series) float64 { + if series == nil || len(series.Points) == 0 { + return 0 + } + avg := p.getAvg(series) + var sum float64 + for _, smpl := range series.Points { + sum += math.Pow(smpl.Value-avg, 2) + } + return math.Sqrt(sum / float64(len(series.Points))) +} + +// getMovingAvg gets the moving average for the given series +// for the given window size and start index +func (p *BaseSeasonalProvider) getMovingAvg(series *v3.Series, movingAvgWindowSize, startIdx int) float64 { + if series == nil || len(series.Points) == 0 { + return 0 + } + if startIdx >= len(series.Points)-movingAvgWindowSize { + startIdx = int(math.Max(0, float64(len(series.Points)-movingAvgWindowSize))) + } + var sum float64 + points := series.Points[startIdx:] + for i := 0; i < movingAvgWindowSize && i < len(points); i++ { + sum += points[i].Value + } + avg := sum / float64(movingAvgWindowSize) + return avg +} + +func (p *BaseSeasonalProvider) getMean(floats ...float64) float64 { + if len(floats) == 0 { + return 0 + } + var sum float64 + for _, f := range floats { + sum += f + } + return sum / float64(len(floats)) +} + +func (p *BaseSeasonalProvider) getPredictedSeries( + series, prevSeries, currentSeasonSeries, pastSeasonSeries, past2SeasonSeries, past3SeasonSeries *v3.Series, +) *v3.Series { + predictedSeries := &v3.Series{ + Labels: series.Labels, + LabelsArray: series.LabelsArray, + Points: []v3.Point{}, + } + + // for each point in the series, get the predicted value + // the predicted value is the moving average (with window size = 7) of the previous period series + // plus the average of the current season series + // minus the mean of the past season series, past2 season series and past3 season series + for idx, curr := range series.Points { + predictedValue := + p.getMovingAvg(prevSeries, movingAvgWindowSize, idx) + + p.getAvg(currentSeasonSeries) - + p.getMean(p.getAvg(pastSeasonSeries), p.getAvg(past2SeasonSeries), p.getAvg(past3SeasonSeries)) + + if predictedValue < 0 { + predictedValue = p.getMovingAvg(prevSeries, movingAvgWindowSize, idx) + } + + zap.L().Info("predictedSeries", + zap.Float64("movingAvg", p.getMovingAvg(prevSeries, movingAvgWindowSize, idx)), + zap.Float64("avg", p.getAvg(currentSeasonSeries)), + zap.Float64("mean", p.getMean(p.getAvg(pastSeasonSeries), p.getAvg(past2SeasonSeries), p.getAvg(past3SeasonSeries))), + zap.Any("labels", series.Labels), + zap.Float64("predictedValue", predictedValue), + ) + predictedSeries.Points = append(predictedSeries.Points, v3.Point{ + Timestamp: curr.Timestamp, + Value: predictedValue, + }) + } + + return predictedSeries +} + +// getBounds gets the upper and lower bounds for the given series +// for the given z score threshold +// moving avg of the previous period series + z score threshold * std dev of the series +// moving avg of the previous period series - z score threshold * std dev of the series +func (p *BaseSeasonalProvider) getBounds( + series, predictedSeries *v3.Series, + zScoreThreshold float64, +) (*v3.Series, *v3.Series) { + upperBoundSeries := &v3.Series{ + Labels: series.Labels, + LabelsArray: series.LabelsArray, + Points: []v3.Point{}, + } + + lowerBoundSeries := &v3.Series{ + Labels: series.Labels, + LabelsArray: series.LabelsArray, + Points: []v3.Point{}, + } + + for idx, curr := range series.Points { + upperBound := p.getMovingAvg(predictedSeries, movingAvgWindowSize, idx) + zScoreThreshold*p.getStdDev(series) + lowerBound := p.getMovingAvg(predictedSeries, movingAvgWindowSize, idx) - zScoreThreshold*p.getStdDev(series) + upperBoundSeries.Points = append(upperBoundSeries.Points, v3.Point{ + Timestamp: curr.Timestamp, + Value: upperBound, + }) + lowerBoundSeries.Points = append(lowerBoundSeries.Points, v3.Point{ + Timestamp: curr.Timestamp, + Value: math.Max(lowerBound, 0), + }) + } + + return upperBoundSeries, lowerBoundSeries +} + +// getExpectedValue gets the expected value for the given series +// for the given index +// prevSeriesAvg + currentSeasonSeriesAvg - mean of past season series, past2 season series and past3 season series +func (p *BaseSeasonalProvider) getExpectedValue( + _, prevSeries, currentSeasonSeries, pastSeasonSeries, past2SeasonSeries, past3SeasonSeries *v3.Series, idx int, +) float64 { + prevSeriesAvg := p.getMovingAvg(prevSeries, movingAvgWindowSize, idx) + currentSeasonSeriesAvg := p.getAvg(currentSeasonSeries) + pastSeasonSeriesAvg := p.getAvg(pastSeasonSeries) + past2SeasonSeriesAvg := p.getAvg(past2SeasonSeries) + past3SeasonSeriesAvg := p.getAvg(past3SeasonSeries) + return prevSeriesAvg + currentSeasonSeriesAvg - p.getMean(pastSeasonSeriesAvg, past2SeasonSeriesAvg, past3SeasonSeriesAvg) +} + +// getScore gets the anomaly score for the given series +// for the given index +// (value - expectedValue) / std dev of the series +func (p *BaseSeasonalProvider) getScore( + series, prevSeries, weekSeries, weekPrevSeries, past2SeasonSeries, past3SeasonSeries *v3.Series, value float64, idx int, +) float64 { + expectedValue := p.getExpectedValue(series, prevSeries, weekSeries, weekPrevSeries, past2SeasonSeries, past3SeasonSeries, idx) + return (value - expectedValue) / p.getStdDev(weekSeries) +} + +// getAnomalyScores gets the anomaly scores for the given series +// for the given index +// (value - expectedValue) / std dev of the series +func (p *BaseSeasonalProvider) getAnomalyScores( + series, prevSeries, currentSeasonSeries, pastSeasonSeries, past2SeasonSeries, past3SeasonSeries *v3.Series, +) *v3.Series { + anomalyScoreSeries := &v3.Series{ + Labels: series.Labels, + LabelsArray: series.LabelsArray, + Points: []v3.Point{}, + } + + for idx, curr := range series.Points { + anomalyScore := p.getScore(series, prevSeries, currentSeasonSeries, pastSeasonSeries, past2SeasonSeries, past3SeasonSeries, curr.Value, idx) + anomalyScoreSeries.Points = append(anomalyScoreSeries.Points, v3.Point{ + Timestamp: curr.Timestamp, + Value: anomalyScore, + }) + } + + return anomalyScoreSeries +} + +func (p *BaseSeasonalProvider) getAnomalies(ctx context.Context, req *GetAnomaliesRequest) (*GetAnomaliesResponse, error) { + anomalyParams := p.getQueryParams(req) + anomalyQueryResults, err := p.getResults(ctx, anomalyParams) + if err != nil { + return nil, err + } + + currentPeriodResultsMap := make(map[string]*v3.Result) + for _, result := range anomalyQueryResults.CurrentPeriodResults { + currentPeriodResultsMap[result.QueryName] = result + } + + pastPeriodResultsMap := make(map[string]*v3.Result) + for _, result := range anomalyQueryResults.PastPeriodResults { + pastPeriodResultsMap[result.QueryName] = result + } + + currentSeasonResultsMap := make(map[string]*v3.Result) + for _, result := range anomalyQueryResults.CurrentSeasonResults { + currentSeasonResultsMap[result.QueryName] = result + } + + pastSeasonResultsMap := make(map[string]*v3.Result) + for _, result := range anomalyQueryResults.PastSeasonResults { + pastSeasonResultsMap[result.QueryName] = result + } + + past2SeasonResultsMap := make(map[string]*v3.Result) + for _, result := range anomalyQueryResults.Past2SeasonResults { + past2SeasonResultsMap[result.QueryName] = result + } + + past3SeasonResultsMap := make(map[string]*v3.Result) + for _, result := range anomalyQueryResults.Past3SeasonResults { + past3SeasonResultsMap[result.QueryName] = result + } + + for _, result := range currentPeriodResultsMap { + funcs := req.Params.CompositeQuery.BuilderQueries[result.QueryName].Functions + + var zScoreThreshold float64 + for _, f := range funcs { + if f.Name == v3.FunctionNameAnomaly { + value, ok := f.NamedArgs["z_score_threshold"] + if ok { + zScoreThreshold = value.(float64) + } else { + zScoreThreshold = 3 + } + break + } + } + + pastPeriodResult, ok := pastPeriodResultsMap[result.QueryName] + if !ok { + continue + } + currentSeasonResult, ok := currentSeasonResultsMap[result.QueryName] + if !ok { + continue + } + pastSeasonResult, ok := pastSeasonResultsMap[result.QueryName] + if !ok { + continue + } + past2SeasonResult, ok := past2SeasonResultsMap[result.QueryName] + if !ok { + continue + } + past3SeasonResult, ok := past3SeasonResultsMap[result.QueryName] + if !ok { + continue + } + + for _, series := range result.Series { + stdDev := p.getStdDev(series) + zap.L().Info("stdDev", zap.Float64("stdDev", stdDev), zap.Any("labels", series.Labels)) + + pastPeriodSeries := p.getMatchingSeries(pastPeriodResult, series) + currentSeasonSeries := p.getMatchingSeries(currentSeasonResult, series) + pastSeasonSeries := p.getMatchingSeries(pastSeasonResult, series) + past2SeasonSeries := p.getMatchingSeries(past2SeasonResult, series) + past3SeasonSeries := p.getMatchingSeries(past3SeasonResult, series) + + prevSeriesAvg := p.getAvg(pastPeriodSeries) + currentSeasonSeriesAvg := p.getAvg(currentSeasonSeries) + pastSeasonSeriesAvg := p.getAvg(pastSeasonSeries) + past2SeasonSeriesAvg := p.getAvg(past2SeasonSeries) + past3SeasonSeriesAvg := p.getAvg(past3SeasonSeries) + zap.L().Info("getAvg", zap.Float64("prevSeriesAvg", prevSeriesAvg), zap.Float64("currentSeasonSeriesAvg", currentSeasonSeriesAvg), zap.Float64("pastSeasonSeriesAvg", pastSeasonSeriesAvg), zap.Float64("past2SeasonSeriesAvg", past2SeasonSeriesAvg), zap.Float64("past3SeasonSeriesAvg", past3SeasonSeriesAvg), zap.Any("labels", series.Labels)) + + predictedSeries := p.getPredictedSeries( + series, + pastPeriodSeries, + currentSeasonSeries, + pastSeasonSeries, + past2SeasonSeries, + past3SeasonSeries, + ) + result.PredictedSeries = append(result.PredictedSeries, predictedSeries) + + upperBoundSeries, lowerBoundSeries := p.getBounds( + series, + predictedSeries, + zScoreThreshold, + ) + result.UpperBoundSeries = append(result.UpperBoundSeries, upperBoundSeries) + result.LowerBoundSeries = append(result.LowerBoundSeries, lowerBoundSeries) + + anomalyScoreSeries := p.getAnomalyScores( + series, + pastPeriodSeries, + currentSeasonSeries, + pastSeasonSeries, + past2SeasonSeries, + past3SeasonSeries, + ) + result.AnomalyScores = append(result.AnomalyScores, anomalyScoreSeries) + } + } + + results := make([]*v3.Result, 0, len(currentPeriodResultsMap)) + for _, result := range currentPeriodResultsMap { + results = append(results, result) + } + + return &GetAnomaliesResponse{ + Results: results, + }, nil +} diff --git a/ee/query-service/anomaly/weekly.go b/ee/query-service/anomaly/weekly.go new file mode 100644 index 0000000000..407e7e6440 --- /dev/null +++ b/ee/query-service/anomaly/weekly.go @@ -0,0 +1,43 @@ +package anomaly + +import ( + "context" + + querierV2 "go.signoz.io/signoz/pkg/query-service/app/querier/v2" + "go.signoz.io/signoz/pkg/query-service/app/queryBuilder" +) + +type WeeklyProvider struct { + BaseSeasonalProvider +} + +var _ BaseProvider = (*WeeklyProvider)(nil) + +func (wp *WeeklyProvider) GetBaseSeasonalProvider() *BaseSeasonalProvider { + return &wp.BaseSeasonalProvider +} + +func NewWeeklyProvider(opts ...GenericProviderOption[*WeeklyProvider]) *WeeklyProvider { + wp := &WeeklyProvider{ + BaseSeasonalProvider: BaseSeasonalProvider{}, + } + + for _, opt := range opts { + opt(wp) + } + + wp.querierV2 = querierV2.NewQuerier(querierV2.QuerierOptions{ + Reader: wp.reader, + Cache: wp.cache, + KeyGenerator: queryBuilder.NewKeyGenerator(), + FluxInterval: wp.fluxInterval, + FeatureLookup: wp.ff, + }) + + return wp +} + +func (p *WeeklyProvider) GetAnomalies(ctx context.Context, req *GetAnomaliesRequest) (*GetAnomaliesResponse, error) { + req.Seasonality = SeasonalityWeekly + return p.getAnomalies(ctx, req) +} diff --git a/ee/query-service/app/api/api.go b/ee/query-service/app/api/api.go index bb36fdf479..82557705fd 100644 --- a/ee/query-service/app/api/api.go +++ b/ee/query-service/app/api/api.go @@ -38,8 +38,7 @@ type APIHandlerOptions struct { Cache cache.Cache Gateway *httputil.ReverseProxy // Querier Influx Interval - FluxInterval time.Duration - + FluxInterval time.Duration UseLogsNewSchema bool } @@ -178,6 +177,8 @@ func (ah *APIHandler) RegisterRoutes(router *mux.Router, am *baseapp.AuthMiddlew am.ViewAccess(ah.listLicensesV2)). Methods(http.MethodGet) + router.HandleFunc("/api/v4/query_range", am.ViewAccess(ah.queryRangeV4)).Methods(http.MethodPost) + // Gateway router.PathPrefix(gateway.RoutePrefix).HandlerFunc(am.AdminAccess(ah.ServeGatewayHTTP)) diff --git a/ee/query-service/app/api/queryrange.go b/ee/query-service/app/api/queryrange.go new file mode 100644 index 0000000000..d4f3eb975a --- /dev/null +++ b/ee/query-service/app/api/queryrange.go @@ -0,0 +1,119 @@ +package api + +import ( + "bytes" + "fmt" + "io" + "net/http" + + "go.signoz.io/signoz/ee/query-service/anomaly" + baseapp "go.signoz.io/signoz/pkg/query-service/app" + "go.signoz.io/signoz/pkg/query-service/app/queryBuilder" + "go.signoz.io/signoz/pkg/query-service/model" + v3 "go.signoz.io/signoz/pkg/query-service/model/v3" + "go.uber.org/zap" +) + +func (aH *APIHandler) queryRangeV4(w http.ResponseWriter, r *http.Request) { + + bodyBytes, _ := io.ReadAll(r.Body) + r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) + + queryRangeParams, apiErrorObj := baseapp.ParseQueryRangeParams(r) + + if apiErrorObj != nil { + zap.L().Error("error parsing metric query range params", zap.Error(apiErrorObj.Err)) + RespondError(w, apiErrorObj, nil) + return + } + queryRangeParams.Version = "v4" + + // add temporality for each metric + temporalityErr := aH.PopulateTemporality(r.Context(), queryRangeParams) + if temporalityErr != nil { + zap.L().Error("Error while adding temporality for metrics", zap.Error(temporalityErr)) + RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: temporalityErr}, nil) + return + } + + anomalyQueryExists := false + anomalyQuery := &v3.BuilderQuery{} + if queryRangeParams.CompositeQuery.QueryType == v3.QueryTypeBuilder { + for _, query := range queryRangeParams.CompositeQuery.BuilderQueries { + for _, fn := range query.Functions { + if fn.Name == v3.FunctionNameAnomaly { + anomalyQueryExists = true + anomalyQuery = query + break + } + } + } + } + + if anomalyQueryExists { + // ensure all queries have metric data source, and there should be only one anomaly query + for _, query := range queryRangeParams.CompositeQuery.BuilderQueries { + if query.DataSource != v3.DataSourceMetrics { + RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("all queries must have metric data source")}, nil) + return + } + } + + // get the threshold, and seasonality from the anomaly query + var seasonality anomaly.Seasonality + for _, fn := range anomalyQuery.Functions { + if fn.Name == v3.FunctionNameAnomaly { + seasonalityStr, ok := fn.NamedArgs["seasonality"].(string) + if !ok { + seasonalityStr = "daily" + } + if seasonalityStr == "weekly" { + seasonality = anomaly.SeasonalityWeekly + } else if seasonalityStr == "daily" { + seasonality = anomaly.SeasonalityDaily + } else { + seasonality = anomaly.SeasonalityHourly + } + break + } + } + var provider anomaly.Provider + switch seasonality { + case anomaly.SeasonalityWeekly: + provider = anomaly.NewWeeklyProvider( + anomaly.WithCache[*anomaly.WeeklyProvider](aH.opts.Cache), + anomaly.WithKeyGenerator[*anomaly.WeeklyProvider](queryBuilder.NewKeyGenerator()), + anomaly.WithReader[*anomaly.WeeklyProvider](aH.opts.DataConnector), + anomaly.WithFeatureLookup[*anomaly.WeeklyProvider](aH.opts.FeatureFlags), + ) + case anomaly.SeasonalityDaily: + provider = anomaly.NewDailyProvider( + anomaly.WithCache[*anomaly.DailyProvider](aH.opts.Cache), + anomaly.WithKeyGenerator[*anomaly.DailyProvider](queryBuilder.NewKeyGenerator()), + anomaly.WithReader[*anomaly.DailyProvider](aH.opts.DataConnector), + anomaly.WithFeatureLookup[*anomaly.DailyProvider](aH.opts.FeatureFlags), + ) + case anomaly.SeasonalityHourly: + provider = anomaly.NewHourlyProvider( + anomaly.WithCache[*anomaly.HourlyProvider](aH.opts.Cache), + anomaly.WithKeyGenerator[*anomaly.HourlyProvider](queryBuilder.NewKeyGenerator()), + anomaly.WithReader[*anomaly.HourlyProvider](aH.opts.DataConnector), + anomaly.WithFeatureLookup[*anomaly.HourlyProvider](aH.opts.FeatureFlags), + ) + } + anomalies, err := provider.GetAnomalies(r.Context(), &anomaly.GetAnomaliesRequest{Params: queryRangeParams}) + if err != nil { + RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil) + return + } + uniqueResults := make(map[string]*v3.Result) + for _, anomaly := range anomalies.Results { + uniqueResults[anomaly.QueryName] = anomaly + uniqueResults[anomaly.QueryName].IsAnomaly = true + } + aH.Respond(w, uniqueResults) + } else { + r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) + aH.QueryRangeV4(w, r) + } +} diff --git a/ee/query-service/app/db/metrics.go b/ee/query-service/app/db/metrics.go deleted file mode 100644 index 0cc8a55c32..0000000000 --- a/ee/query-service/app/db/metrics.go +++ /dev/null @@ -1,401 +0,0 @@ -package db - -import ( - "context" - "crypto/md5" - "encoding/json" - "fmt" - "reflect" - "regexp" - "sort" - "strings" - "time" - - "go.signoz.io/signoz/ee/query-service/model" - baseconst "go.signoz.io/signoz/pkg/query-service/constants" - basemodel "go.signoz.io/signoz/pkg/query-service/model" - "go.signoz.io/signoz/pkg/query-service/utils" - "go.uber.org/zap" -) - -// GetMetricResultEE runs the query and returns list of time series -func (r *ClickhouseReader) GetMetricResultEE(ctx context.Context, query string) ([]*basemodel.Series, string, error) { - - defer utils.Elapsed("GetMetricResult", nil)() - zap.L().Info("Executing metric result query: ", zap.String("query", query)) - - var hash string - // If getSubTreeSpans function is used in the clickhouse query - if strings.Contains(query, "getSubTreeSpans(") { - var err error - query, hash, err = r.getSubTreeSpansCustomFunction(ctx, query, hash) - if err == fmt.Errorf("no spans found for the given query") { - return nil, "", nil - } - if err != nil { - return nil, "", err - } - } - - rows, err := r.conn.Query(ctx, query) - if err != nil { - zap.L().Error("Error in processing query", zap.Error(err)) - return nil, "", fmt.Errorf("error in processing query") - } - - var ( - columnTypes = rows.ColumnTypes() - columnNames = rows.Columns() - vars = make([]interface{}, len(columnTypes)) - ) - for i := range columnTypes { - vars[i] = reflect.New(columnTypes[i].ScanType()).Interface() - } - // when group by is applied, each combination of cartesian product - // of attributes is separate series. each item in metricPointsMap - // represent a unique series. - metricPointsMap := make(map[string][]basemodel.MetricPoint) - // attribute key-value pairs for each group selection - attributesMap := make(map[string]map[string]string) - - defer rows.Close() - for rows.Next() { - if err := rows.Scan(vars...); err != nil { - return nil, "", err - } - var groupBy []string - var metricPoint basemodel.MetricPoint - groupAttributes := make(map[string]string) - // Assuming that the end result row contains a timestamp, value and option labels - // Label key and value are both strings. - for idx, v := range vars { - colName := columnNames[idx] - switch v := v.(type) { - case *string: - // special case for returning all labels - if colName == "fullLabels" { - var metric map[string]string - err := json.Unmarshal([]byte(*v), &metric) - if err != nil { - return nil, "", err - } - for key, val := range metric { - groupBy = append(groupBy, val) - groupAttributes[key] = val - } - } else { - groupBy = append(groupBy, *v) - groupAttributes[colName] = *v - } - case *time.Time: - metricPoint.Timestamp = v.UnixMilli() - case *float64: - metricPoint.Value = *v - case **float64: - // ch seems to return this type when column is derived from - // SELECT count(*)/ SELECT count(*) - floatVal := *v - if floatVal != nil { - metricPoint.Value = *floatVal - } - case *float32: - float32Val := float32(*v) - metricPoint.Value = float64(float32Val) - case *uint8, *uint64, *uint16, *uint32: - if _, ok := baseconst.ReservedColumnTargetAliases[colName]; ok { - metricPoint.Value = float64(reflect.ValueOf(v).Elem().Uint()) - } else { - groupBy = append(groupBy, fmt.Sprintf("%v", reflect.ValueOf(v).Elem().Uint())) - groupAttributes[colName] = fmt.Sprintf("%v", reflect.ValueOf(v).Elem().Uint()) - } - case *int8, *int16, *int32, *int64: - if _, ok := baseconst.ReservedColumnTargetAliases[colName]; ok { - metricPoint.Value = float64(reflect.ValueOf(v).Elem().Int()) - } else { - groupBy = append(groupBy, fmt.Sprintf("%v", reflect.ValueOf(v).Elem().Int())) - groupAttributes[colName] = fmt.Sprintf("%v", reflect.ValueOf(v).Elem().Int()) - } - default: - zap.L().Error("invalid var found in metric builder query result", zap.Any("var", v), zap.String("colName", colName)) - } - } - sort.Strings(groupBy) - key := strings.Join(groupBy, "") - attributesMap[key] = groupAttributes - metricPointsMap[key] = append(metricPointsMap[key], metricPoint) - } - - var seriesList []*basemodel.Series - for key := range metricPointsMap { - points := metricPointsMap[key] - // first point in each series could be invalid since the - // aggregations are applied with point from prev series - if len(points) != 0 && len(points) > 1 { - points = points[1:] - } - attributes := attributesMap[key] - series := basemodel.Series{Labels: attributes, Points: points} - seriesList = append(seriesList, &series) - } - // err = r.conn.Exec(ctx, "DROP TEMPORARY TABLE IF EXISTS getSubTreeSpans"+hash) - // if err != nil { - // zap.L().Error("Error in dropping temporary table: ", err) - // return nil, err - // } - if hash == "" { - return seriesList, hash, nil - } else { - return seriesList, "getSubTreeSpans" + hash, nil - } -} - -func (r *ClickhouseReader) getSubTreeSpansCustomFunction(ctx context.Context, query string, hash string) (string, string, error) { - - zap.L().Debug("Executing getSubTreeSpans function") - - // str1 := `select fromUnixTimestamp64Milli(intDiv( toUnixTimestamp64Milli ( timestamp ), 100) * 100) AS interval, toFloat64(count()) as count from (select timestamp, spanId, parentSpanId, durationNano from getSubTreeSpans(select * from signoz_traces.signoz_index_v2 where serviceName='frontend' and name='/driver.DriverService/FindNearest' and traceID='00000000000000004b0a863cb5ed7681') where name='FindDriverIDs' group by interval order by interval asc;` - - // process the query to fetch subTree query - var subtreeInput string - query, subtreeInput, hash = processQuery(query, hash) - - err := r.conn.Exec(ctx, "DROP TABLE IF EXISTS getSubTreeSpans"+hash) - if err != nil { - zap.L().Error("Error in dropping temporary table", zap.Error(err)) - return query, hash, err - } - - // Create temporary table to store the getSubTreeSpans() results - zap.L().Debug("Creating temporary table getSubTreeSpans", zap.String("hash", hash)) - err = r.conn.Exec(ctx, "CREATE TABLE IF NOT EXISTS "+"getSubTreeSpans"+hash+" (timestamp DateTime64(9) CODEC(DoubleDelta, LZ4), traceID FixedString(32) CODEC(ZSTD(1)), spanID String CODEC(ZSTD(1)), parentSpanID String CODEC(ZSTD(1)), rootSpanID String CODEC(ZSTD(1)), serviceName LowCardinality(String) CODEC(ZSTD(1)), name LowCardinality(String) CODEC(ZSTD(1)), rootName LowCardinality(String) CODEC(ZSTD(1)), durationNano UInt64 CODEC(T64, ZSTD(1)), kind Int8 CODEC(T64, ZSTD(1)), tagMap Map(LowCardinality(String), String) CODEC(ZSTD(1)), events Array(String) CODEC(ZSTD(2))) ENGINE = MergeTree() ORDER BY (timestamp)") - if err != nil { - zap.L().Error("Error in creating temporary table", zap.Error(err)) - return query, hash, err - } - - var getSpansSubQueryDBResponses []model.GetSpansSubQueryDBResponse - getSpansSubQuery := subtreeInput - // Execute the subTree query - zap.L().Debug("Executing subTree query", zap.String("query", getSpansSubQuery)) - err = r.conn.Select(ctx, &getSpansSubQueryDBResponses, getSpansSubQuery) - - // zap.L().Info(getSpansSubQuery) - - if err != nil { - zap.L().Error("Error in processing sql query", zap.Error(err)) - return query, hash, fmt.Errorf("error in processing sql query") - } - - var searchScanResponses []basemodel.SearchSpanDBResponseItem - - // TODO : @ankit: I think the algorithm does not need to assume that subtrees are from the same TraceID. We can take this as an improvement later. - // Fetch all the spans from of same TraceID so that we can build subtree - modelQuery := fmt.Sprintf("SELECT timestamp, traceID, model FROM %s.%s WHERE traceID=$1", r.TraceDB, r.SpansTable) - - if len(getSpansSubQueryDBResponses) == 0 { - return query, hash, fmt.Errorf("no spans found for the given query") - } - zap.L().Debug("Executing query to fetch all the spans from the same TraceID: ", zap.String("modelQuery", modelQuery)) - err = r.conn.Select(ctx, &searchScanResponses, modelQuery, getSpansSubQueryDBResponses[0].TraceID) - - if err != nil { - zap.L().Error("Error in processing sql query", zap.Error(err)) - return query, hash, fmt.Errorf("error in processing sql query") - } - - // Process model to fetch the spans - zap.L().Debug("Processing model to fetch the spans") - searchSpanResponses := []basemodel.SearchSpanResponseItem{} - for _, item := range searchScanResponses { - var jsonItem basemodel.SearchSpanResponseItem - json.Unmarshal([]byte(item.Model), &jsonItem) - jsonItem.TimeUnixNano = uint64(item.Timestamp.UnixNano()) - if jsonItem.Events == nil { - jsonItem.Events = []string{} - } - searchSpanResponses = append(searchSpanResponses, jsonItem) - } - // Build the subtree and store all the subtree spans in temporary table getSubTreeSpans+hash - // Use map to store pointer to the spans to avoid duplicates and save memory - zap.L().Debug("Building the subtree to store all the subtree spans in temporary table getSubTreeSpans", zap.String("hash", hash)) - - treeSearchResponse, err := getSubTreeAlgorithm(searchSpanResponses, getSpansSubQueryDBResponses) - if err != nil { - zap.L().Error("Error in getSubTreeAlgorithm function", zap.Error(err)) - return query, hash, err - } - zap.L().Debug("Preparing batch to store subtree spans in temporary table getSubTreeSpans", zap.String("hash", hash)) - statement, err := r.conn.PrepareBatch(context.Background(), fmt.Sprintf("INSERT INTO getSubTreeSpans"+hash)) - if err != nil { - zap.L().Error("Error in preparing batch statement", zap.Error(err)) - return query, hash, err - } - for _, span := range treeSearchResponse { - var parentID string - if len(span.References) > 0 && span.References[0].RefType == "CHILD_OF" { - parentID = span.References[0].SpanId - } - err = statement.Append( - time.Unix(0, int64(span.TimeUnixNano)), - span.TraceID, - span.SpanID, - parentID, - span.RootSpanID, - span.ServiceName, - span.Name, - span.RootName, - uint64(span.DurationNano), - int8(span.Kind), - span.TagMap, - span.Events, - ) - if err != nil { - zap.L().Error("Error in processing sql query", zap.Error(err)) - return query, hash, err - } - } - zap.L().Debug("Inserting the subtree spans in temporary table getSubTreeSpans", zap.String("hash", hash)) - err = statement.Send() - if err != nil { - zap.L().Error("Error in sending statement", zap.Error(err)) - return query, hash, err - } - return query, hash, nil -} - -//lint:ignore SA4009 return hash is feeded to the query -func processQuery(query string, hash string) (string, string, string) { - re3 := regexp.MustCompile(`getSubTreeSpans`) - - submatchall3 := re3.FindAllStringIndex(query, -1) - getSubtreeSpansMatchIndex := submatchall3[0][1] - - query2countParenthesis := query[getSubtreeSpansMatchIndex:] - - sqlCompleteIndex := 0 - countParenthesisImbalance := 0 - for i, char := range query2countParenthesis { - - if string(char) == "(" { - countParenthesisImbalance += 1 - } - if string(char) == ")" { - countParenthesisImbalance -= 1 - } - if countParenthesisImbalance == 0 { - sqlCompleteIndex = i - break - } - } - subtreeInput := query2countParenthesis[1:sqlCompleteIndex] - - // hash the subtreeInput - hmd5 := md5.Sum([]byte(subtreeInput)) - hash = fmt.Sprintf("%x", hmd5) - - // Reformat the query to use the getSubTreeSpans function - query = query[:getSubtreeSpansMatchIndex] + hash + " " + query2countParenthesis[sqlCompleteIndex+1:] - return query, subtreeInput, hash -} - -// getSubTreeAlgorithm is an algorithm to build the subtrees of the spans and return the list of spans -func getSubTreeAlgorithm(payload []basemodel.SearchSpanResponseItem, getSpansSubQueryDBResponses []model.GetSpansSubQueryDBResponse) (map[string]*basemodel.SearchSpanResponseItem, error) { - - var spans []*model.SpanForTraceDetails - for _, spanItem := range payload { - var parentID string - if len(spanItem.References) > 0 && spanItem.References[0].RefType == "CHILD_OF" { - parentID = spanItem.References[0].SpanId - } - span := &model.SpanForTraceDetails{ - TimeUnixNano: spanItem.TimeUnixNano, - SpanID: spanItem.SpanID, - TraceID: spanItem.TraceID, - ServiceName: spanItem.ServiceName, - Name: spanItem.Name, - Kind: spanItem.Kind, - DurationNano: spanItem.DurationNano, - TagMap: spanItem.TagMap, - ParentID: parentID, - Events: spanItem.Events, - HasError: spanItem.HasError, - } - spans = append(spans, span) - } - - zap.L().Debug("Building Tree") - roots, err := buildSpanTrees(&spans) - if err != nil { - return nil, err - } - searchSpansResult := make(map[string]*basemodel.SearchSpanResponseItem) - // Every span which was fetched from getSubTree Input SQL query is considered root - // For each root, get the subtree spans - for _, getSpansSubQueryDBResponse := range getSpansSubQueryDBResponses { - targetSpan := &model.SpanForTraceDetails{} - // zap.L().Debug("Building tree for span id: " + getSpansSubQueryDBResponse.SpanID + " " + strconv.Itoa(i+1) + " of " + strconv.Itoa(len(getSpansSubQueryDBResponses))) - // Search target span object in the tree - for _, root := range roots { - targetSpan, err = breadthFirstSearch(root, getSpansSubQueryDBResponse.SpanID) - if targetSpan != nil { - break - } - if err != nil { - zap.L().Error("Error during BreadthFirstSearch()", zap.Error(err)) - return nil, err - } - } - if targetSpan == nil { - return nil, nil - } - // Build subtree for the target span - // Mark the target span as root by setting parent ID as empty string - targetSpan.ParentID = "" - preParents := []*model.SpanForTraceDetails{targetSpan} - children := []*model.SpanForTraceDetails{} - - // Get the subtree child spans - for i := 0; len(preParents) != 0; i++ { - parents := []*model.SpanForTraceDetails{} - for _, parent := range preParents { - children = append(children, parent.Children...) - parents = append(parents, parent.Children...) - } - preParents = parents - } - - resultSpans := children - // Add the target span to the result spans - resultSpans = append(resultSpans, targetSpan) - - for _, item := range resultSpans { - references := []basemodel.OtelSpanRef{ - { - TraceId: item.TraceID, - SpanId: item.ParentID, - RefType: "CHILD_OF", - }, - } - - if item.Events == nil { - item.Events = []string{} - } - searchSpansResult[item.SpanID] = &basemodel.SearchSpanResponseItem{ - TimeUnixNano: item.TimeUnixNano, - SpanID: item.SpanID, - TraceID: item.TraceID, - ServiceName: item.ServiceName, - Name: item.Name, - Kind: item.Kind, - References: references, - DurationNano: item.DurationNano, - TagMap: item.TagMap, - Events: item.Events, - HasError: item.HasError, - RootSpanID: getSpansSubQueryDBResponse.SpanID, - RootName: targetSpan.Name, - } - } - } - return searchSpansResult, nil -} diff --git a/ee/query-service/app/server.go b/ee/query-service/app/server.go index 9845ee670b..54eb7bd1e5 100644 --- a/ee/query-service/app/server.go +++ b/ee/query-service/app/server.go @@ -170,6 +170,14 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) { return nil, err } } + var c cache.Cache + if serverOptions.CacheConfigPath != "" { + cacheOpts, err := cache.LoadFromYAMLCacheConfigFile(serverOptions.CacheConfigPath) + if err != nil { + return nil, err + } + c = cache.NewCache(cacheOpts) + } <-readerReady rm, err := makeRulesManager(serverOptions.PromConfigPath, @@ -177,6 +185,7 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) { serverOptions.RuleRepoURL, localDB, reader, + c, serverOptions.DisableRules, lm, serverOptions.UseLogsNewSchema, @@ -237,15 +246,6 @@ func NewServer(serverOptions *ServerOptions) (*Server, error) { telemetry.GetInstance().SetReader(reader) telemetry.GetInstance().SetSaasOperator(constants.SaasSegmentKey) - var c cache.Cache - if serverOptions.CacheConfigPath != "" { - cacheOpts, err := cache.LoadFromYAMLCacheConfigFile(serverOptions.CacheConfigPath) - if err != nil { - return nil, err - } - c = cache.NewCache(cacheOpts) - } - fluxInterval, err := time.ParseDuration(serverOptions.FluxInterval) if err != nil { @@ -732,6 +732,7 @@ func makeRulesManager( ruleRepoURL string, db *sqlx.DB, ch baseint.Reader, + cache cache.Cache, disableRules bool, fm baseint.FeatureLookup, useLogsNewSchema bool) (*baserules.Manager, error) { @@ -760,6 +761,7 @@ func makeRulesManager( DisableRules: disableRules, FeatureFlags: fm, Reader: ch, + Cache: cache, EvalDelay: baseconst.GetEvalDelay(), PrepareTaskFunc: rules.PrepareTaskFunc, diff --git a/ee/query-service/model/plans.go b/ee/query-service/model/plans.go index dbd8b56965..5b695143b7 100644 --- a/ee/query-service/model/plans.go +++ b/ee/query-service/model/plans.go @@ -13,7 +13,6 @@ const Onboarding = "ONBOARDING" const ChatSupport = "CHAT_SUPPORT" const Gateway = "GATEWAY" const PremiumSupport = "PREMIUM_SUPPORT" -const QueryBuilderSearchV2 = "QUERY_BUILDER_SEARCH_V2" var BasicPlan = basemodel.FeatureSet{ basemodel.Feature{ @@ -129,7 +128,7 @@ var BasicPlan = basemodel.FeatureSet{ Route: "", }, basemodel.Feature{ - Name: QueryBuilderSearchV2, + Name: basemodel.AnomalyDetection, Active: false, Usage: 0, UsageLimit: -1, @@ -244,8 +243,8 @@ var ProPlan = basemodel.FeatureSet{ Route: "", }, basemodel.Feature{ - Name: QueryBuilderSearchV2, - Active: false, + Name: basemodel.AnomalyDetection, + Active: true, Usage: 0, UsageLimit: -1, Route: "", @@ -373,8 +372,8 @@ var EnterprisePlan = basemodel.FeatureSet{ Route: "", }, basemodel.Feature{ - Name: QueryBuilderSearchV2, - Active: false, + Name: basemodel.AnomalyDetection, + Active: true, Usage: 0, UsageLimit: -1, Route: "", diff --git a/ee/query-service/rules/anomaly.go b/ee/query-service/rules/anomaly.go new file mode 100644 index 0000000000..a04bfc2840 --- /dev/null +++ b/ee/query-service/rules/anomaly.go @@ -0,0 +1,393 @@ +package rules + +import ( + "context" + "encoding/json" + "fmt" + "math" + "strings" + "sync" + "time" + + "go.uber.org/zap" + + "go.signoz.io/signoz/ee/query-service/anomaly" + "go.signoz.io/signoz/pkg/query-service/cache" + "go.signoz.io/signoz/pkg/query-service/common" + "go.signoz.io/signoz/pkg/query-service/model" + + querierV2 "go.signoz.io/signoz/pkg/query-service/app/querier/v2" + "go.signoz.io/signoz/pkg/query-service/app/queryBuilder" + "go.signoz.io/signoz/pkg/query-service/interfaces" + v3 "go.signoz.io/signoz/pkg/query-service/model/v3" + "go.signoz.io/signoz/pkg/query-service/utils/labels" + "go.signoz.io/signoz/pkg/query-service/utils/times" + "go.signoz.io/signoz/pkg/query-service/utils/timestamp" + + "go.signoz.io/signoz/pkg/query-service/formatter" + + baserules "go.signoz.io/signoz/pkg/query-service/rules" + + yaml "gopkg.in/yaml.v2" +) + +const ( + RuleTypeAnomaly = "anomaly_rule" +) + +type AnomalyRule struct { + *baserules.BaseRule + + mtx sync.Mutex + + reader interfaces.Reader + + // querierV2 is used for alerts created after the introduction of new metrics query builder + querierV2 interfaces.Querier + + provider anomaly.Provider + + seasonality anomaly.Seasonality +} + +func NewAnomalyRule( + id string, + p *baserules.PostableRule, + featureFlags interfaces.FeatureLookup, + reader interfaces.Reader, + cache cache.Cache, + opts ...baserules.RuleOption, +) (*AnomalyRule, error) { + + zap.L().Info("creating new AnomalyRule", zap.String("id", id), zap.Any("opts", opts)) + + baseRule, err := baserules.NewBaseRule(id, p, reader, opts...) + if err != nil { + return nil, err + } + + t := AnomalyRule{ + BaseRule: baseRule, + } + + switch strings.ToLower(p.RuleCondition.Seasonality) { + case "hourly": + t.seasonality = anomaly.SeasonalityHourly + case "daily": + t.seasonality = anomaly.SeasonalityDaily + case "weekly": + t.seasonality = anomaly.SeasonalityWeekly + default: + t.seasonality = anomaly.SeasonalityDaily + } + + zap.L().Info("using seasonality", zap.String("seasonality", t.seasonality.String())) + + querierOptsV2 := querierV2.QuerierOptions{ + Reader: reader, + Cache: cache, + KeyGenerator: queryBuilder.NewKeyGenerator(), + FeatureLookup: featureFlags, + } + + t.querierV2 = querierV2.NewQuerier(querierOptsV2) + t.reader = reader + if t.seasonality == anomaly.SeasonalityHourly { + t.provider = anomaly.NewHourlyProvider( + anomaly.WithCache[*anomaly.HourlyProvider](cache), + anomaly.WithKeyGenerator[*anomaly.HourlyProvider](queryBuilder.NewKeyGenerator()), + anomaly.WithReader[*anomaly.HourlyProvider](reader), + anomaly.WithFeatureLookup[*anomaly.HourlyProvider](featureFlags), + ) + } else if t.seasonality == anomaly.SeasonalityDaily { + t.provider = anomaly.NewDailyProvider( + anomaly.WithCache[*anomaly.DailyProvider](cache), + anomaly.WithKeyGenerator[*anomaly.DailyProvider](queryBuilder.NewKeyGenerator()), + anomaly.WithReader[*anomaly.DailyProvider](reader), + anomaly.WithFeatureLookup[*anomaly.DailyProvider](featureFlags), + ) + } else if t.seasonality == anomaly.SeasonalityWeekly { + t.provider = anomaly.NewWeeklyProvider( + anomaly.WithCache[*anomaly.WeeklyProvider](cache), + anomaly.WithKeyGenerator[*anomaly.WeeklyProvider](queryBuilder.NewKeyGenerator()), + anomaly.WithReader[*anomaly.WeeklyProvider](reader), + anomaly.WithFeatureLookup[*anomaly.WeeklyProvider](featureFlags), + ) + } + return &t, nil +} + +func (r *AnomalyRule) Type() baserules.RuleType { + return RuleTypeAnomaly +} + +func (r *AnomalyRule) prepareQueryRange(ts time.Time) (*v3.QueryRangeParamsV3, error) { + + zap.L().Info("prepareQueryRange", zap.Int64("ts", ts.UnixMilli()), zap.Int64("evalWindow", r.EvalWindow().Milliseconds()), zap.Int64("evalDelay", r.EvalDelay().Milliseconds())) + + start := ts.Add(-time.Duration(r.EvalWindow())).UnixMilli() + end := ts.UnixMilli() + + if r.EvalDelay() > 0 { + start = start - int64(r.EvalDelay().Milliseconds()) + end = end - int64(r.EvalDelay().Milliseconds()) + } + // round to minute otherwise we could potentially miss data + start = start - (start % (60 * 1000)) + end = end - (end % (60 * 1000)) + + compositeQuery := r.Condition().CompositeQuery + + if compositeQuery.PanelType != v3.PanelTypeGraph { + compositeQuery.PanelType = v3.PanelTypeGraph + } + + // default mode + return &v3.QueryRangeParamsV3{ + Start: start, + End: end, + Step: int64(math.Max(float64(common.MinAllowedStepInterval(start, end)), 60)), + CompositeQuery: compositeQuery, + Variables: make(map[string]interface{}, 0), + NoCache: false, + }, nil +} + +func (r *AnomalyRule) GetSelectedQuery() string { + return r.Condition().GetSelectedQueryName() +} + +func (r *AnomalyRule) buildAndRunQuery(ctx context.Context, ts time.Time) (baserules.Vector, error) { + + params, err := r.prepareQueryRange(ts) + if err != nil { + return nil, err + } + err = r.PopulateTemporality(ctx, params) + if err != nil { + return nil, fmt.Errorf("internal error while setting temporality") + } + + anomalies, err := r.provider.GetAnomalies(ctx, &anomaly.GetAnomaliesRequest{ + Params: params, + Seasonality: r.seasonality, + }) + if err != nil { + return nil, err + } + + var queryResult *v3.Result + for _, result := range anomalies.Results { + if result.QueryName == r.GetSelectedQuery() { + queryResult = result + break + } + } + + var resultVector baserules.Vector + + scoresJSON, _ := json.Marshal(queryResult.AnomalyScores) + zap.L().Info("anomaly scores", zap.String("scores", string(scoresJSON))) + + for _, series := range queryResult.AnomalyScores { + smpl, shouldAlert := r.ShouldAlert(*series) + if shouldAlert { + resultVector = append(resultVector, smpl) + } + } + return resultVector, nil +} + +func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (interface{}, error) { + + prevState := r.State() + + valueFormatter := formatter.FromUnit(r.Unit()) + res, err := r.buildAndRunQuery(ctx, ts) + + if err != nil { + return nil, err + } + + r.mtx.Lock() + defer r.mtx.Unlock() + + resultFPs := map[uint64]struct{}{} + var alerts = make(map[uint64]*baserules.Alert, len(res)) + + for _, smpl := range res { + l := make(map[string]string, len(smpl.Metric)) + for _, lbl := range smpl.Metric { + l[lbl.Name] = lbl.Value + } + + value := valueFormatter.Format(smpl.V, r.Unit()) + threshold := valueFormatter.Format(r.TargetVal(), r.Unit()) + zap.L().Debug("Alert template data for rule", zap.String("name", r.Name()), zap.String("formatter", valueFormatter.Name()), zap.String("value", value), zap.String("threshold", threshold)) + + tmplData := baserules.AlertTemplateData(l, value, threshold) + // Inject some convenience variables that are easier to remember for users + // who are not used to Go's templating system. + defs := "{{$labels := .Labels}}{{$value := .Value}}{{$threshold := .Threshold}}" + + // utility function to apply go template on labels and annotations + expand := func(text string) string { + + tmpl := baserules.NewTemplateExpander( + ctx, + defs+text, + "__alert_"+r.Name(), + tmplData, + times.Time(timestamp.FromTime(ts)), + nil, + ) + result, err := tmpl.Expand() + if err != nil { + result = fmt.Sprintf("
+
+
+ Note: Billing metrics are updated once every 24 hours.
+
+
) : (
-
- {title}
-
-
);
}
diff --git a/frontend/src/container/GridCardLayout/styles.ts b/frontend/src/container/GridCardLayout/styles.ts
index e3f24308de..df2004da52 100644
--- a/frontend/src/container/GridCardLayout/styles.ts
+++ b/frontend/src/container/GridCardLayout/styles.ts
@@ -33,7 +33,14 @@ export const Card = styled(CardComponent)
- {
+ e.stopPropagation();
+ e.preventDefault();
+ setShowGlobalSearch(false);
+ }}
+ className="search-header-icons"
+ />
+ }
+ key={widget.id}
+ onChange={(e): void => {
+ setSearchTerm(e.target.value || '');
+ }}
+ />
+ ) : (
+ <>
+
-
-
- )}
-
-
-
+ {title}
+
+ {threshold}
- {isFetchingResponse && !queryResponse.isError && (
-
+
+
+ )}
+
+ {isWarning && (
+
+
+ )}
+ {globalSearchAvailable && (
+ setShowGlobalSearch(true)}
+ data-testid="widget-header-search"
+ />
+ )}
+
+
+
+
+ )}
{threshold}
+ {isFetchingResponse && !queryResponse.isError && (
+
+
+ );
+ }
+
+ return (
+
+
+
+
+ {podName && (
+
+
+ )}
+
+ {/* TODO(Rahul): Make a common config driven component for this and other infra metrics components */}
+ {selectedView === VIEW_TYPES.NODE && (
+
+ );
+}
+
+export default InfraMetrics;
diff --git a/frontend/src/container/LogDetailedView/InfraMetrics/NodeMetrics.tsx b/frontend/src/container/LogDetailedView/InfraMetrics/NodeMetrics.tsx
new file mode 100644
index 0000000000..3c935c8b89
--- /dev/null
+++ b/frontend/src/container/LogDetailedView/InfraMetrics/NodeMetrics.tsx
@@ -0,0 +1,140 @@
+import { Card, Col, Row, Skeleton, Typography } from 'antd';
+import cx from 'classnames';
+import Uplot from 'components/Uplot';
+import { ENTITY_VERSION_V4 } from 'constants/app';
+import dayjs from 'dayjs';
+import { useIsDarkMode } from 'hooks/useDarkMode';
+import { useResizeObserver } from 'hooks/useDimensions';
+import { GetMetricQueryRange } from 'lib/dashboard/getQueryResults';
+import { getUPlotChartOptions } from 'lib/uPlotLib/getUplotChartOptions';
+import { getUPlotChartData } from 'lib/uPlotLib/utils/getUplotChartData';
+import { useMemo, useRef } from 'react';
+import { useQueries, UseQueryResult } from 'react-query';
+import { SuccessResponse } from 'types/api';
+import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+
+import {
+ getHostQueryPayload,
+ getNodeQueryPayload,
+ hostWidgetInfo,
+ nodeWidgetInfo,
+} from './constants';
+
+function NodeMetrics({
+ nodeName,
+ clusterName,
+ hostName,
+ logLineTimestamp,
+}: {
+ nodeName: string;
+ clusterName: string;
+ hostName: string;
+ logLineTimestamp: string;
+}): JSX.Element {
+ const { start, end, verticalLineTimestamp } = useMemo(() => {
+ const logTimestamp = dayjs(logLineTimestamp);
+ const now = dayjs();
+ const startTime = logTimestamp.subtract(3, 'hour');
+
+ const endTime = logTimestamp.add(3, 'hour').isBefore(now)
+ ? logTimestamp.add(3, 'hour')
+ : now;
+
+ return {
+ start: startTime.unix(),
+ end: endTime.unix(),
+ verticalLineTimestamp: logTimestamp.unix(),
+ };
+ }, [logLineTimestamp]);
+
+ const queryPayloads = useMemo(() => {
+ if (nodeName) {
+ return getNodeQueryPayload(clusterName, nodeName, start, end);
+ }
+ return getHostQueryPayload(hostName, start, end);
+ }, [nodeName, hostName, clusterName, start, end]);
+
+ const widgetInfo = nodeName ? nodeWidgetInfo : hostWidgetInfo;
+ const queries = useQueries(
+ queryPayloads.map((payload) => ({
+ queryKey: ['metrics', payload, ENTITY_VERSION_V4, 'NODE'],
+ queryFn: (): Promise
+
+ Node
+
+
+
+ {errorMessage}
;
+ }
+ return (
+
+
+ );
+ };
+ return (
+ {errorMessage}
;
+ }
+ return (
+
+
+ );
+ };
+
+ return (
+
- {isSearchV2Enabled ? (
-
)}
diff --git a/frontend/src/container/LogsExplorerChart/LogsExplorerChart.interfaces.ts b/frontend/src/container/LogsExplorerChart/LogsExplorerChart.interfaces.ts
index a19a41d778..ee447242eb 100644
--- a/frontend/src/container/LogsExplorerChart/LogsExplorerChart.interfaces.ts
+++ b/frontend/src/container/LogsExplorerChart/LogsExplorerChart.interfaces.ts
@@ -3,6 +3,7 @@ import { QueryData } from 'types/api/widgets/getQuery';
export type LogsExplorerChartProps = {
data: QueryData[];
isLoading: boolean;
+ isLogsExplorerViews?: boolean;
isLabelEnabled?: boolean;
className?: string;
};
diff --git a/frontend/src/container/LogsExplorerChart/index.tsx b/frontend/src/container/LogsExplorerChart/index.tsx
index 7f4d648529..7ac1934bb7 100644
--- a/frontend/src/container/LogsExplorerChart/index.tsx
+++ b/frontend/src/container/LogsExplorerChart/index.tsx
@@ -16,12 +16,14 @@ import { UpdateTimeInterval } from 'store/actions';
import { LogsExplorerChartProps } from './LogsExplorerChart.interfaces';
import { CardStyled } from './LogsExplorerChart.styled';
+import { getColorsForSeverityLabels } from './utils';
function LogsExplorerChart({
data,
isLoading,
isLabelEnabled = true,
className,
+ isLogsExplorerViews = false,
}: LogsExplorerChartProps): JSX.Element {
const dispatch = useDispatch();
const urlQuery = useUrlQuery();
@@ -29,15 +31,19 @@ function LogsExplorerChart({
const handleCreateDatasets: Required
+ 
30 ? title : ''}>
- {' '}
+ {' '}
{title}
diff --git a/frontend/src/container/NewDashboard/DashboardVariablesSelection/DashboardVariableSelection.styles.scss b/frontend/src/container/NewDashboard/DashboardVariablesSelection/DashboardVariableSelection.styles.scss
index f7fcb83a53..6df3e79906 100644
--- a/frontend/src/container/NewDashboard/DashboardVariablesSelection/DashboardVariableSelection.styles.scss
+++ b/frontend/src/container/NewDashboard/DashboardVariablesSelection/DashboardVariableSelection.styles.scss
@@ -43,6 +43,15 @@
.ant-select-item {
display: flex;
align-items: center;
+ gap: 8px;
+ }
+
+ .rc-virtual-list-holder {
+ [data-testid='option-ALL'] {
+ border-bottom: 1px solid var(--bg-slate-400);
+ padding-bottom: 12px;
+ margin-bottom: 8px;
+ }
}
.all-label {
@@ -56,28 +65,25 @@
}
.dropdown-value {
- display: flex;
- justify-content: space-between;
- align-items: center;
+ display: grid;
+ grid-template-columns: 1fr max-content;
.option-text {
- max-width: 180px;
padding: 0 8px;
}
.toggle-tag-label {
padding-left: 8px;
right: 40px;
- font-weight: normal;
- position: absolute;
+ font-weight: 500;
}
}
}
}
.dropdown-styles {
- min-width: 300px;
- max-width: 350px;
+ min-width: 400px;
+ max-width: 500px;
}
.lightMode {
diff --git a/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.test.tsx b/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.test.tsx
index 0c8fbd51ae..1cb89d6b95 100644
--- a/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.test.tsx
+++ b/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.test.tsx
@@ -1,14 +1,8 @@
import '@testing-library/jest-dom/extend-expect';
-import {
- act,
- fireEvent,
- render,
- screen,
- waitFor,
-} from '@testing-library/react';
import MockQueryClientProvider from 'providers/test/MockQueryClientProvider';
import React, { useEffect } from 'react';
+import { act, fireEvent, render, screen, waitFor } from 'tests/test-utils';
import { IDashboardVariable } from 'types/api/dashboard/getAll';
import VariableItem from './VariableItem';
diff --git a/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.tsx b/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.tsx
index baa8228b3c..a0a444a715 100644
--- a/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.tsx
+++ b/frontend/src/container/NewDashboard/DashboardVariablesSelection/VariableItem.tsx
@@ -1,3 +1,4 @@
+/* eslint-disable sonarjs/cognitive-complexity */
/* eslint-disable jsx-a11y/click-events-have-key-events */
/* eslint-disable jsx-a11y/no-static-element-interactions */
/* eslint-disable @typescript-eslint/no-explicit-any */
@@ -25,8 +26,11 @@ import { debounce, isArray, isString } from 'lodash-es';
import map from 'lodash-es/map';
import { ChangeEvent, memo, useEffect, useMemo, useState } from 'react';
import { useQuery } from 'react-query';
+import { useSelector } from 'react-redux';
+import { AppState } from 'store/reducers';
import { IDashboardVariable } from 'types/api/dashboard/getAll';
import { VariableResponseProps } from 'types/api/dashboard/variables/query';
+import { GlobalReducer } from 'types/reducer/globalTime';
import { popupContainer } from 'utils/selectPopupContainer';
import { variablePropsToPayloadVariables } from '../utils';
@@ -58,14 +62,14 @@ interface VariableItemProps {
const getSelectValue = (
selectedValue: IDashboardVariable['selectedValue'],
variableData: IDashboardVariable,
-): string | string[] => {
+): string | string[] | undefined => {
if (Array.isArray(selectedValue)) {
if (!variableData.multiSelect && selectedValue.length === 1) {
- return selectedValue[0]?.toString() || '';
+ return selectedValue[0]?.toString();
}
return selectedValue.map((item) => item.toString());
}
- return selectedValue?.toString() || '';
+ return selectedValue?.toString();
};
// eslint-disable-next-line sonarjs/cognitive-complexity
@@ -80,6 +84,23 @@ function VariableItem({
[],
);
+ const { maxTime, minTime } = useSelector(
+ (state) => state.globalTime,
+ );
+
+ useEffect(() => {
+ if (variableData.allSelected && variableData.type === 'QUERY') {
+ setVariablesToGetUpdated((prev) => {
+ const variablesQueue = [...prev.filter((v) => v !== variableData.name)];
+ if (variableData.name) {
+ variablesQueue.push(variableData.name);
+ }
+ return variablesQueue;
+ });
+ }
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, [minTime, maxTime]);
+
const [errorMessage, setErrorMessage] = useState(null);
const getDependentVariables = (queryValue: string): string[] => {
@@ -111,7 +132,14 @@ function VariableItem({
const variableKey = dependentVariablesStr.replace(/\s/g, '');
- return [REACT_QUERY_KEY.DASHBOARD_BY_ID, variableName, variableKey];
+ // added this time dependency for variables query as API respects the passed time range now
+ return [
+ REACT_QUERY_KEY.DASHBOARD_BY_ID,
+ variableName,
+ variableKey,
+ `${minTime}`,
+ `${maxTime}`,
+ ];
};
// eslint-disable-next-line sonarjs/cognitive-complexity
@@ -151,10 +179,14 @@ function VariableItem({
valueNotInList = true;
}
}
+ // variablesData.allSelected is added for the case where on change of options we need to update the
+ // local storage
if (
variableData.type === 'QUERY' &&
variableData.name &&
- (variablesToGetUpdated.includes(variableData.name) || valueNotInList)
+ (variablesToGetUpdated.includes(variableData.name) ||
+ valueNotInList ||
+ variableData.allSelected)
) {
let value = variableData.selectedValue;
let allSelected = false;
@@ -268,7 +300,7 @@ function VariableItem({
e.stopPropagation();
e.preventDefault();
const isChecked =
- variableData.allSelected || selectValue.includes(ALL_SELECT_VALUE);
+ variableData.allSelected || selectValue?.includes(ALL_SELECT_VALUE);
if (isChecked) {
handleChange([]);
@@ -338,8 +370,8 @@ function VariableItem({
(Array.isArray(selectValue) && selectValue?.includes(option.toString()));
if (isChecked) {
- if (mode === ToggleTagValue.Only) {
- handleChange(option.toString());
+ if (mode === ToggleTagValue.Only && variableData.multiSelect) {
+ handleChange([option.toString()]);
} else if (!variableData.multiSelect) {
handleChange(option.toString());
} else {
@@ -430,6 +462,7 @@ function VariableItem({
+ {omittedValues.length}
)}
+ allowClear
>
{enableSelectAll && (
@@ -468,11 +501,17 @@ function VariableItem({
{...retProps(option as string)}
onClick={(e): void => handleToggle(e as any, option as string)}
>
-
-
- {option.toString()}
-
-
+
+ {option.toString()}
+
{variableData.multiSelect &&
optionState.tag === option.toString() &&
diff --git a/frontend/src/container/NewWidget/RightContainer/constants.ts b/frontend/src/container/NewWidget/RightContainer/constants.ts
index 171f6b81d3..03cee96d21 100644
--- a/frontend/src/container/NewWidget/RightContainer/constants.ts
+++ b/frontend/src/container/NewWidget/RightContainer/constants.ts
@@ -74,7 +74,7 @@ export const panelTypeVsYAxisUnit: { [key in PANEL_TYPES]: boolean } = {
[PANEL_TYPES.VALUE]: true,
[PANEL_TYPES.TABLE]: false,
[PANEL_TYPES.LIST]: false,
- [PANEL_TYPES.PIE]: false,
+ [PANEL_TYPES.PIE]: true,
[PANEL_TYPES.BAR]: true,
[PANEL_TYPES.HISTOGRAM]: false,
[PANEL_TYPES.TRACE]: false,
diff --git a/frontend/src/container/NewWidget/RightContainer/index.tsx b/frontend/src/container/NewWidget/RightContainer/index.tsx
index 84400737d4..43e3b5611d 100644
--- a/frontend/src/container/NewWidget/RightContainer/index.tsx
+++ b/frontend/src/container/NewWidget/RightContainer/index.tsx
@@ -211,7 +211,11 @@ function RightContainer({
;
+ searchTerm?: string;
customTooltipElement?: HTMLDivElement;
};
diff --git a/frontend/src/container/PipelinePage/Layouts/ChangeHistory/tests/ChangeHistory.test.tsx b/frontend/src/container/PipelinePage/Layouts/ChangeHistory/tests/ChangeHistory.test.tsx
index 194acbea0a..88fdb5d594 100644
--- a/frontend/src/container/PipelinePage/Layouts/ChangeHistory/tests/ChangeHistory.test.tsx
+++ b/frontend/src/container/PipelinePage/Layouts/ChangeHistory/tests/ChangeHistory.test.tsx
@@ -9,6 +9,20 @@ import store from 'store';
import ChangeHistory from '../index';
import { pipelineData, pipelineDataHistory } from './testUtils';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
const queryClient = new QueryClient({
defaultOptions: {
queries: {
diff --git a/frontend/src/container/PipelinePage/tests/AddNewPipeline.test.tsx b/frontend/src/container/PipelinePage/tests/AddNewPipeline.test.tsx
index 8990ffa4e7..360a7c5925 100644
--- a/frontend/src/container/PipelinePage/tests/AddNewPipeline.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/AddNewPipeline.test.tsx
@@ -9,6 +9,20 @@ import store from 'store';
import { pipelineMockData } from '../mocks/pipeline';
import AddNewPipeline from '../PipelineListsView/AddNewPipeline';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
export function matchMedia(): void {
Object.defineProperty(window, 'matchMedia', {
writable: true,
diff --git a/frontend/src/container/PipelinePage/tests/AddNewProcessor.test.tsx b/frontend/src/container/PipelinePage/tests/AddNewProcessor.test.tsx
index a4d2e680a4..d3f236437f 100644
--- a/frontend/src/container/PipelinePage/tests/AddNewProcessor.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/AddNewProcessor.test.tsx
@@ -9,6 +9,20 @@ import { pipelineMockData } from '../mocks/pipeline';
import AddNewProcessor from '../PipelineListsView/AddNewProcessor';
import { matchMedia } from './AddNewPipeline.test';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
beforeAll(() => {
matchMedia();
});
diff --git a/frontend/src/container/PipelinePage/tests/DeleteAction.test.tsx b/frontend/src/container/PipelinePage/tests/DeleteAction.test.tsx
index 451ef8807f..3b2fdfeb34 100644
--- a/frontend/src/container/PipelinePage/tests/DeleteAction.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/DeleteAction.test.tsx
@@ -6,6 +6,20 @@ import { MemoryRouter } from 'react-router-dom';
import i18n from 'ReactI18';
import store from 'store';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
describe('PipelinePage container test', () => {
it('should render DeleteAction section', () => {
const { asFragment } = render(
diff --git a/frontend/src/container/PipelinePage/tests/DragAction.test.tsx b/frontend/src/container/PipelinePage/tests/DragAction.test.tsx
index 168b3f042f..9f64714072 100644
--- a/frontend/src/container/PipelinePage/tests/DragAction.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/DragAction.test.tsx
@@ -6,6 +6,20 @@ import { MemoryRouter } from 'react-router-dom';
import i18n from 'ReactI18';
import store from 'store';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
describe('PipelinePage container test', () => {
it('should render DragAction section', () => {
const { asFragment } = render(
diff --git a/frontend/src/container/PipelinePage/tests/EditAction.test.tsx b/frontend/src/container/PipelinePage/tests/EditAction.test.tsx
index c52991bf6d..56dd779600 100644
--- a/frontend/src/container/PipelinePage/tests/EditAction.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/EditAction.test.tsx
@@ -6,6 +6,20 @@ import { MemoryRouter } from 'react-router-dom';
import i18n from 'ReactI18';
import store from 'store';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
describe('PipelinePage container test', () => {
it('should render EditAction section', () => {
const { asFragment } = render(
diff --git a/frontend/src/container/PipelinePage/tests/PipelineActions.test.tsx b/frontend/src/container/PipelinePage/tests/PipelineActions.test.tsx
index 83f503107b..d472f4745c 100644
--- a/frontend/src/container/PipelinePage/tests/PipelineActions.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/PipelineActions.test.tsx
@@ -8,6 +8,20 @@ import store from 'store';
import { pipelineMockData } from '../mocks/pipeline';
import PipelineActions from '../PipelineListsView/TableComponents/PipelineActions';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
describe('PipelinePage container test', () => {
it('should render PipelineActions section', () => {
const { asFragment } = render(
diff --git a/frontend/src/container/PipelinePage/tests/PipelineExpandView.test.tsx b/frontend/src/container/PipelinePage/tests/PipelineExpandView.test.tsx
index 6875d11259..b9c78091dd 100644
--- a/frontend/src/container/PipelinePage/tests/PipelineExpandView.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/PipelineExpandView.test.tsx
@@ -9,6 +9,20 @@ import { pipelineMockData } from '../mocks/pipeline';
import PipelineExpandView from '../PipelineListsView/PipelineExpandView';
import { matchMedia } from './AddNewPipeline.test';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
beforeAll(() => {
matchMedia();
});
diff --git a/frontend/src/container/PipelinePage/tests/PipelineListsView.test.tsx b/frontend/src/container/PipelinePage/tests/PipelineListsView.test.tsx
index 74f1f125e0..517e623ebe 100644
--- a/frontend/src/container/PipelinePage/tests/PipelineListsView.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/PipelineListsView.test.tsx
@@ -11,6 +11,20 @@ import store from 'store';
import { pipelineApiResponseMockData } from '../mocks/pipeline';
import PipelineListsView from '../PipelineListsView';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
const samplePipelinePreviewResponse = {
isLoading: false,
logs: [
diff --git a/frontend/src/container/PipelinePage/tests/PipelinePageLayout.test.tsx b/frontend/src/container/PipelinePage/tests/PipelinePageLayout.test.tsx
index 91d5dfe244..a71bc1266d 100644
--- a/frontend/src/container/PipelinePage/tests/PipelinePageLayout.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/PipelinePageLayout.test.tsx
@@ -11,6 +11,20 @@ import { v4 } from 'uuid';
import PipelinePageLayout from '../Layouts/Pipeline';
import { matchMedia } from './AddNewPipeline.test';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
beforeAll(() => {
matchMedia();
});
diff --git a/frontend/src/container/PipelinePage/tests/TagInput.test.tsx b/frontend/src/container/PipelinePage/tests/TagInput.test.tsx
index 24cedc2eb0..e95efb6715 100644
--- a/frontend/src/container/PipelinePage/tests/TagInput.test.tsx
+++ b/frontend/src/container/PipelinePage/tests/TagInput.test.tsx
@@ -7,6 +7,20 @@ import store from 'store';
import TagInput from '../components/TagInput';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
describe('Pipeline Page', () => {
it('should render TagInput section', () => {
const { asFragment } = render(
diff --git a/frontend/src/container/PipelinePage/tests/utils.test.ts b/frontend/src/container/PipelinePage/tests/utils.test.ts
index c21e8c5a4b..707ad06c2d 100644
--- a/frontend/src/container/PipelinePage/tests/utils.test.ts
+++ b/frontend/src/container/PipelinePage/tests/utils.test.ts
@@ -11,6 +11,20 @@ import {
getTableColumn,
} from '../PipelineListsView/utils';
+jest.mock('uplot', () => {
+ const paths = {
+ spline: jest.fn(),
+ bars: jest.fn(),
+ };
+ const uplotMock = jest.fn(() => ({
+ paths,
+ }));
+ return {
+ paths,
+ default: uplotMock,
+ };
+});
+
describe('Utils testing of Pipeline Page', () => {
test('it should be check form field of add pipeline', () => {
expect(pipelineFields.length).toBe(3);
diff --git a/frontend/src/container/QueryBuilder/components/Query/Query.tsx b/frontend/src/container/QueryBuilder/components/Query/Query.tsx
index 747198abfb..453cf063f8 100644
--- a/frontend/src/container/QueryBuilder/components/Query/Query.tsx
+++ b/frontend/src/container/QueryBuilder/components/Query/Query.tsx
@@ -23,6 +23,7 @@ import {
import AggregateEveryFilter from 'container/QueryBuilder/filters/AggregateEveryFilter';
import LimitFilter from 'container/QueryBuilder/filters/LimitFilter/LimitFilter';
import QueryBuilderSearch from 'container/QueryBuilder/filters/QueryBuilderSearch';
+import QueryBuilderSearchV2 from 'container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2';
import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
// ** Hooks
@@ -81,6 +82,10 @@ export const Query = memo(function Query({
entityVersion: version,
});
+ const isLogsExplorerPage = useMemo(() => pathname === ROUTES.LOGS_EXPLORER, [
+ pathname,
+ ]);
+
const handleChangeAggregateEvery = useCallback(
(value: IBuilderQuery['stepInterval']) => {
handleChangeQueryData('stepInterval', value);
@@ -452,11 +457,19 @@ export const Query = memo(function Query({
)}
(
initialHavingValues,
);
+ const [errorMessage, setErrorMessage] = useState(null);
const { isMulti } = useTagValidation(
currentFormValue.op,
@@ -198,6 +200,29 @@ export function HavingFilter({
resetChanges();
};
+ const handleFocus = useCallback(() => {
+ setErrorMessage(null);
+ }, []);
+
+ const handleBlur = useCallback((): void => {
+ if (searchText) {
+ const { columnName, op, value } = getHavingObject(searchText);
+ const isCompleteHavingClause =
+ columnName && op && value.every((v) => v !== '');
+
+ if (isCompleteHavingClause && isValidHavingValue(searchText)) {
+ setLocalValues((prev) => {
+ const updatedValues = [...prev, searchText];
+ onChange(updatedValues.map(transformFromStringToHaving));
+ return updatedValues;
+ });
+ setSearchText('');
+ } else {
+ setErrorMessage('Invalid HAVING clause');
+ }
+ }
+ }, [searchText, onChange]);
+
useEffect(() => {
parseSearchText(searchText);
}, [searchText, parseSearchText]);
@@ -209,28 +234,36 @@ export function HavingFilter({
const isMetricsDataSource = query.dataSource === DataSource.METRICS;
return (
-
+ <>
+
+ {errorMessage && (
+ ;
dataSource?: RowData[];
sticky?: TableProps['sticky'];
+ searchTerm?: string;
};
diff --git a/frontend/src/container/QueryTable/QueryTable.tsx b/frontend/src/container/QueryTable/QueryTable.tsx
index 1786e5d4e3..e438070173 100644
--- a/frontend/src/container/QueryTable/QueryTable.tsx
+++ b/frontend/src/container/QueryTable/QueryTable.tsx
@@ -3,8 +3,11 @@ import './QueryTable.styles.scss';
import { ResizeTable } from 'components/ResizeTable';
import Download from 'container/Download/Download';
import { IServiceName } from 'container/MetricsApplication/Tabs/types';
-import { createTableColumnsFromQuery } from 'lib/query/createTableColumnsFromQuery';
-import { useMemo } from 'react';
+import {
+ createTableColumnsFromQuery,
+ RowData,
+} from 'lib/query/createTableColumnsFromQuery';
+import { useCallback, useEffect, useMemo, useState } from 'react';
import { useParams } from 'react-router-dom';
import { QueryTableProps } from './QueryTable.intefaces';
@@ -20,6 +23,7 @@ export function QueryTable({
columns,
dataSource,
sticky,
+ searchTerm,
...props
}: QueryTableProps): JSX.Element {
const { isDownloadEnabled = false, fileName = '' } = downloadOption || {};
@@ -55,6 +59,27 @@ export function QueryTable({
hideOnSinglePage: true,
};
+ const [filterTable, setFilterTable] = useState(null);
+
+ const onTableSearch = useCallback(
+ (value?: string): void => {
+ const filterTable = newDataSource.filter((o) =>
+ Object.keys(o).some((k) =>
+ String(o[k])
+ .toLowerCase()
+ .includes(value?.toLowerCase() || ''),
+ ),
+ );
+
+ setFilterTable(filterTable);
+ },
+ [newDataSource],
+ );
+
+ useEffect(() => {
+ onTableSearch(searchTerm);
+ }, [newDataSource, onTableSearch, searchTerm]);
+
return (
{errorMessage}
+ )}
+
);
}
diff --git a/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.styles.scss b/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.styles.scss
index 1ca8bd7529..624546fed5 100644
--- a/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.styles.scss
+++ b/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.styles.scss
@@ -2,6 +2,10 @@
display: flex;
gap: 4px;
+ .ant-select-dropdown {
+ padding: 0px;
+ }
+
.show-all-filters {
.content {
.rc-virtual-list-holder {
@@ -231,16 +235,16 @@
}
&.resource {
- border: 1px solid rgba(242, 71, 105, 0.2);
+ border: 1px solid #4bcff920;
.ant-typography {
- color: var(--bg-sakura-400);
- background: rgba(245, 108, 135, 0.1);
+ color: var(--bg-aqua-400);
+ background: #4bcff910;
font-size: 14px;
}
.ant-tag-close-icon {
- background: rgba(245, 108, 135, 0.1);
+ background: #4bcff910;
}
}
&.tag {
@@ -259,3 +263,110 @@
}
}
}
+
+.lightMode {
+ .query-builder-search-v2 {
+ .content {
+ .operator-for {
+ .operator-for-text {
+ color: var(--bg-ink-200);
+ }
+
+ .operator-for-value {
+ background: rgba(255, 255, 255, 0.1);
+ color: var(--bg-ink-200);
+ }
+ }
+
+ .value-for {
+ .value-for-text {
+ color: var(--bg-ink-200);
+ }
+
+ .value-for-value {
+ background: rgba(255, 255, 255, 0.1);
+ color: var(--bg-ink-400);
+ }
+ }
+ .example-queries {
+ cursor: default;
+ .heading {
+ color: var(--bg-slate-50);
+ }
+
+ .query-container {
+ .example-query {
+ background: var(--bg-vanilla-200);
+ color: var(--bg-ink-400);
+ }
+
+ .example-query:hover {
+ color: var(--bg-ink-100);
+ }
+ }
+ }
+ }
+
+ .keyboard-shortcuts {
+ border: 1px solid var(--bg-vanilla-300);
+ background: var(--bg-vanilla-200);
+
+ .icons {
+ border-top: 1.143px solid var(--bg-ink-200);
+ border-right: 1.143px solid var(--bg-ink-200);
+ border-bottom: 2.286px solid var(--bg-ink-200);
+ border-left: 1.143px solid var(--bg-ink-200);
+ background: var(--bg-vanilla-300);
+ }
+
+ .keyboard-text {
+ color: var(--bg-ink-400);
+ }
+
+ .navigate {
+ border-right: 1px solid #1d212d;
+ }
+
+ .show-all-filter-items {
+ border-left: 1px solid #1d212d;
+ }
+ }
+
+ .qb-search-bar-tokenised-tags {
+ .ant-tag {
+ border: 1px solid var(--bg-slate-100);
+ background: var(--bg-vanilla-300);
+ box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, 0.1);
+
+ .ant-typography {
+ color: var(--bg-ink-100);
+ }
+
+ &.resource {
+ border: 1px solid #4bcff920;
+
+ .ant-typography {
+ color: var(--bg-aqua-400);
+ background: #4bcff910;
+ }
+
+ .ant-tag-close-icon {
+ background: #4bcff910;
+ }
+ }
+ &.tag {
+ border: 1px solid rgba(189, 153, 121, 0.2);
+
+ .ant-typography {
+ color: var(--bg-sienna-400);
+ background: rgba(189, 153, 121, 0.1);
+ }
+
+ .ant-tag-close-icon {
+ background: rgba(189, 153, 121, 0.1);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.tsx b/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.tsx
index 3ddeef85bc..0925c10d97 100644
--- a/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.tsx
+++ b/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/QueryBuilderSearchV2.tsx
@@ -286,16 +286,62 @@ function QueryBuilderSearchV2(
parsedValue = value;
}
if (currentState === DropdownState.ATTRIBUTE_KEY) {
- setCurrentFilterItem((prev) => ({
- ...prev,
- key: parsedValue as BaseAutocompleteData,
- op: '',
- value: '',
- }));
- setCurrentState(DropdownState.OPERATOR);
- setSearchValue((parsedValue as BaseAutocompleteData)?.key);
+ // Case - convert abc def ghi type attribute keys directly to body contains abc def ghi
+ if (
+ isObject(parsedValue) &&
+ parsedValue?.key &&
+ parsedValue?.key?.split(' ').length > 1
+ ) {
+ setTags((prev) => [
+ ...prev,
+ {
+ key: {
+ key: 'body',
+ dataType: DataTypes.String,
+ type: '',
+ isColumn: true,
+ isJSON: false,
+ // eslint-disable-next-line sonarjs/no-duplicate-string
+ id: 'body--string----true',
+ },
+ op: OPERATORS.CONTAINS,
+ value: (parsedValue as BaseAutocompleteData)?.key,
+ },
+ ]);
+ setCurrentFilterItem(undefined);
+ setSearchValue('');
+ setCurrentState(DropdownState.ATTRIBUTE_KEY);
+ } else {
+ setCurrentFilterItem((prev) => ({
+ ...prev,
+ key: parsedValue as BaseAutocompleteData,
+ op: '',
+ value: '',
+ }));
+ setCurrentState(DropdownState.OPERATOR);
+ setSearchValue((parsedValue as BaseAutocompleteData)?.key);
+ }
} else if (currentState === DropdownState.OPERATOR) {
- if (value === OPERATORS.EXISTS || value === OPERATORS.NOT_EXISTS) {
+ if (isEmpty(value) && currentFilterItem?.key?.key) {
+ setTags((prev) => [
+ ...prev,
+ {
+ key: {
+ key: 'body',
+ dataType: DataTypes.String,
+ type: '',
+ isColumn: true,
+ isJSON: false,
+ id: 'body--string----true',
+ },
+ op: OPERATORS.CONTAINS,
+ value: currentFilterItem?.key?.key,
+ },
+ ]);
+ setCurrentFilterItem(undefined);
+ setSearchValue('');
+ setCurrentState(DropdownState.ATTRIBUTE_KEY);
+ } else if (value === OPERATORS.EXISTS || value === OPERATORS.NOT_EXISTS) {
setTags((prev) => [
...prev,
{
@@ -399,6 +445,7 @@ function QueryBuilderSearchV2(
whereClauseConfig?.customKey === 'body' &&
whereClauseConfig?.customOp === OPERATORS.CONTAINS
) {
+ // eslint-disable-next-line sonarjs/no-identical-functions
setTags((prev) => [
...prev,
{
@@ -519,19 +566,20 @@ function QueryBuilderSearchV2(
setCurrentState(DropdownState.OPERATOR);
}
}
- if (suggestionsData?.payload?.attributes?.length === 0) {
+ // again let's not auto select anything for the user
+ if (tagOperator) {
setCurrentFilterItem({
key: {
- key: tagKey.split(' ')[0],
+ key: tagKey,
dataType: DataTypes.EMPTY,
type: '',
isColumn: false,
isJSON: false,
},
- op: '',
+ op: tagOperator,
value: '',
});
- setCurrentState(DropdownState.OPERATOR);
+ setCurrentState(DropdownState.ATTRIBUTE_VALUE);
}
} else if (
// Case 2 - if key is defined but the search text doesn't match with the set key,
@@ -607,13 +655,32 @@ function QueryBuilderSearchV2(
// the useEffect takes care of setting the dropdown values correctly on change of the current state
useEffect(() => {
if (currentState === DropdownState.ATTRIBUTE_KEY) {
+ const { tagKey } = getTagToken(searchValue);
if (isLogsExplorerPage) {
- setDropdownOptions(
- suggestionsData?.payload?.attributes?.map((key) => ({
+ // add the user typed option in the dropdown to select that and move ahead irrespective of the matches and all
+ setDropdownOptions([
+ ...(!isEmpty(tagKey) &&
+ !suggestionsData?.payload?.attributes?.some((val) =>
+ isEqual(val.key, tagKey),
+ )
+ ? [
+ {
+ label: tagKey,
+ value: {
+ key: tagKey,
+ dataType: DataTypes.EMPTY,
+ type: '',
+ isColumn: false,
+ isJSON: false,
+ },
+ },
+ ]
+ : []),
+ ...(suggestionsData?.payload?.attributes?.map((key) => ({
label: key.key,
value: key,
- })) || [],
- );
+ })) || []),
+ ]);
} else {
setDropdownOptions(
data?.payload?.attributeKeys?.map((key) => ({
@@ -643,12 +710,14 @@ function QueryBuilderSearchV2(
op.label.startsWith(partialOperator.toLocaleUpperCase()),
);
}
+ operatorOptions = [{ label: '', value: '' }, ...operatorOptions];
setDropdownOptions(operatorOptions);
} else if (strippedKey.endsWith('[*]') && strippedKey.startsWith('body.')) {
operatorOptions = [OPERATORS.HAS, OPERATORS.NHAS].map((operator) => ({
label: operator,
value: operator,
}));
+ operatorOptions = [{ label: '', value: '' }, ...operatorOptions];
setDropdownOptions(operatorOptions);
} else {
operatorOptions = QUERY_BUILDER_OPERATORS_BY_TYPES.universal.map(
@@ -663,6 +732,7 @@ function QueryBuilderSearchV2(
op.label.startsWith(partialOperator.toLocaleUpperCase()),
);
}
+ operatorOptions = [{ label: '', value: '' }, ...operatorOptions];
setDropdownOptions(operatorOptions);
}
}
@@ -729,7 +799,8 @@ function QueryBuilderSearchV2(
}, [tags]);
useEffect(() => {
- if (!isEqual(query.filters.items, tags)) {
+ // convert the query and tags to same format before comparison
+ if (!isEqual(getInitTags(query), tags)) {
setTags(getInitTags(query));
}
// eslint-disable-next-line react-hooks/exhaustive-deps
@@ -769,7 +840,7 @@ function QueryBuilderSearchV2(
);
const queryTags = useMemo(
- () => tags.map((tag) => `${tag.key.key} ${tag.op} ${tag.value}`),
+ () => tags.map((tag) => `${tag.key?.key} ${tag.op} ${tag.value}`),
[tags],
);
diff --git a/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/Suggestions.styles.scss b/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/Suggestions.styles.scss
index bd7ad36a5a..153f32e5ee 100644
--- a/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/Suggestions.styles.scss
+++ b/frontend/src/container/QueryBuilder/filters/QueryBuilderSearchV2/Suggestions.styles.scss
@@ -77,14 +77,14 @@
&.resource {
border-radius: 50px;
- background: rgba(245, 108, 135, 0.1) !important;
- color: var(--bg-sakura-400) !important;
+ background: #4bcff910 !important;
+ color: var(--bg-aqua-400) !important;
.dot {
- background-color: var(--bg-sakura-400);
+ background-color: var(--bg-aqua-400);
}
.text {
- color: var(--bg-sakura-400);
+ color: var(--bg-aqua-400);
font-family: Inter;
font-size: 12px;
font-style: normal;
@@ -168,3 +168,59 @@
}
}
}
+
+.lightMode {
+ .text {
+ color: var(--bg-ink-400);
+ }
+
+ .option {
+ .container {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+
+ .right-section {
+ .data-type {
+ background: var(--bg-vanilla-300);
+ }
+ }
+ .option-meta-data-container {
+ display: flex;
+ gap: 8px;
+ }
+ }
+
+ .container-without-tag {
+ .left {
+ .OPERATOR {
+ color: var(--bg-ink-400);
+ }
+
+ .VALUE {
+ color: var(--bg-ink-400);
+ }
+ }
+
+ .right {
+ .data-type {
+ background: var(--bg-vanilla-300);
+ }
+ }
+ }
+ }
+ .option:hover {
+ .container {
+ .left-section {
+ .value {
+ color: var(--bg-ink-100);
+ }
+ }
+ }
+ .container-without-tag {
+ .value {
+ color: var(--bg-ink-100);
+ }
+ }
+ }
+}
diff --git a/frontend/src/container/QueryTable/QueryTable.intefaces.ts b/frontend/src/container/QueryTable/QueryTable.intefaces.ts
index 7576d796ec..254e4885e7 100644
--- a/frontend/src/container/QueryTable/QueryTable.intefaces.ts
+++ b/frontend/src/container/QueryTable/QueryTable.intefaces.ts
@@ -19,4 +19,5 @@ export type QueryTableProps = Omit<
columns?: ColumnsType
{isDownloadEnabled && (
@@ -69,7 +94,7 @@ export function QueryTable({
({
+ ...jest.requireActual('react-router-dom'),
+ useLocation: (): { pathname: string } => ({
+ pathname: ``,
+ }),
+}));
+
+// Mock useDashabord hook
+jest.mock('providers/Dashboard/Dashboard', () => ({
+ useDashboard: (): any => ({
+ selectedDashboard: {
+ data: {
+ variables: [],
+ },
+ },
+ }),
+}));
+
+describe('QueryTable -', () => {
+ it('should render correctly with all the data rows', () => {
+ const { container } = render(
+
)}
diff --git a/frontend/src/container/ServiceApplication/ServiceTraces/ServiceTracesTable.tsx b/frontend/src/container/ServiceApplication/ServiceTraces/ServiceTracesTable.tsx
index 6633b7a1aa..42d22e8980 100644
--- a/frontend/src/container/ServiceApplication/ServiceTraces/ServiceTracesTable.tsx
+++ b/frontend/src/container/ServiceApplication/ServiceTraces/ServiceTracesTable.tsx
@@ -49,10 +49,11 @@ function ServiceTraceTable({
return (
<>
{RPS > MAX_RPS_LIMIT && (
-
-
+
+
+ email
+
)}
diff --git a/frontend/src/container/SideNav/menuItems.tsx b/frontend/src/container/SideNav/menuItems.tsx
index be694227a1..6d24b74c53 100644
--- a/frontend/src/container/SideNav/menuItems.tsx
+++ b/frontend/src/container/SideNav/menuItems.tsx
@@ -1,7 +1,6 @@
import { RocketOutlined } from '@ant-design/icons';
import ROUTES from 'constants/routes';
import {
- AreaChart,
BarChart2,
BellDot,
BugIcon,
@@ -114,11 +113,6 @@ const menuItems: SidebarItem[] = [
icon: => ({
- onClick: (event): void => {
- event.preventDefault();
- event.stopPropagation();
- if (event.metaKey || event.ctrlKey) {
- window.open(getTraceLink(record), '_blank');
- } else {
- history.push(getTraceLink(record));
- }
- },
- }),
- [],
- );
-
const handleDragColumn = useCallback(
(fromIndex: number, toIndex: number) =>
onDragColumns(columns, fromIndex, toIndex),
@@ -169,7 +153,6 @@ function ListView({ isFilterApplied }: ListViewProps): JSX.Element {
style={tableStyles}
dataSource={transformedQueryTableData}
columns={columns}
- onRow={handleRow}
onDragColumn={handleDragColumn}
/>
)}
diff --git a/frontend/src/container/TracesExplorer/ListView/utils.tsx b/frontend/src/container/TracesExplorer/ListView/utils.tsx
index a6201436d1..dc0e3808ae 100644
--- a/frontend/src/container/TracesExplorer/ListView/utils.tsx
+++ b/frontend/src/container/TracesExplorer/ListView/utils.tsx
@@ -47,11 +47,11 @@ export const getListColumns = (
key: 'date',
title: 'Timestamp',
width: 145,
- render: (item): JSX.Element => {
+ render: (value, item): JSX.Element => {
const date =
- typeof item === 'string'
- ? dayjs(item).format('YYYY-MM-DD HH:mm:ss.SSS')
- : dayjs(item / 1e6).format('YYYY-MM-DD HH:mm:ss.SSS');
+ typeof value === 'string'
+ ? dayjs(value).format('YYYY-MM-DD HH:mm:ss.SSS')
+ : dayjs(value / 1e6).format('YYYY-MM-DD HH:mm:ss.SSS');
return (
{date}
@@ -67,10 +67,10 @@ export const getListColumns = (
dataIndex: key,
key: `${key}-${dataType}-${type}`,
width: 145,
- render: (value): JSX.Element => {
+ render: (value, item): JSX.Element => {
if (value === '') {
return (
-
+
N/A
);
@@ -78,7 +78,7 @@ export const getListColumns = (
if (key === 'httpMethod' || key === 'responseStatusCode') {
return (
-
+
{value}
@@ -88,14 +88,14 @@ export const getListColumns = (
if (key === 'durationNano') {
return (
-
+
{getMs(value)}ms
);
}
return (
-
+
{value}
);
diff --git a/frontend/src/container/TracesTableComponent/TracesTableComponent.styles.scss b/frontend/src/container/TracesTableComponent/TracesTableComponent.styles.scss
index 74e80f8764..c59bf3c5ad 100644
--- a/frontend/src/container/TracesTableComponent/TracesTableComponent.styles.scss
+++ b/frontend/src/container/TracesTableComponent/TracesTableComponent.styles.scss
@@ -52,6 +52,8 @@
height: 40px;
justify-content: end;
padding: 0 8px;
+ margin-top: 12px;
+ margin-bottom: 2px;
}
}
diff --git a/frontend/src/hooks/logs/useActiveLog.ts b/frontend/src/hooks/logs/useActiveLog.ts
index 0a968c4650..d7cc498f9f 100644
--- a/frontend/src/hooks/logs/useActiveLog.ts
+++ b/frontend/src/hooks/logs/useActiveLog.ts
@@ -1,6 +1,6 @@
import { getAggregateKeys } from 'api/queryBuilder/getAttributeKeys';
import { SOMETHING_WENT_WRONG } from 'constants/api';
-import { QueryBuilderKeys } from 'constants/queryBuilder';
+import { OPERATORS, QueryBuilderKeys } from 'constants/queryBuilder';
import ROUTES from 'constants/routes';
import { getOperatorValue } from 'container/QueryBuilder/filters/QueryBuilderSearch/utils';
import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
@@ -24,6 +24,16 @@ import { v4 as uuid } from 'uuid';
import { UseActiveLog } from './types';
+export function getOldLogsOperatorFromNew(operator: string): string {
+ switch (operator) {
+ case OPERATORS['=']:
+ return OPERATORS.IN;
+ case OPERATORS['!=']:
+ return OPERATORS.NIN;
+ default:
+ return operator;
+ }
+}
export const useActiveLog = (): UseActiveLog => {
const dispatch = useDispatch();
@@ -178,10 +188,11 @@ export const useActiveLog = (): UseActiveLog => {
);
const onAddToQueryLogs = useCallback(
(fieldKey: string, fieldValue: string, operator: string) => {
+ const newOperator = getOldLogsOperatorFromNew(operator);
const updatedQueryString = getGeneratedFilterQueryString(
fieldKey,
fieldValue,
- operator,
+ newOperator,
queryString,
);
diff --git a/frontend/src/hooks/queryBuilder/useFetchKeysAndValues.ts b/frontend/src/hooks/queryBuilder/useFetchKeysAndValues.ts
index 6fd42175ad..7b99b9d250 100644
--- a/frontend/src/hooks/queryBuilder/useFetchKeysAndValues.ts
+++ b/frontend/src/hooks/queryBuilder/useFetchKeysAndValues.ts
@@ -70,7 +70,7 @@ export const useFetchKeysAndValues = (
const queryFiltersWithoutId = useMemo(
() => ({
...query.filters,
- items: query.filters.items.map((item) => {
+ items: query.filters?.items?.map((item) => {
const filterWithoutId = cloneDeep(item);
unset(filterWithoutId, 'id');
return filterWithoutId;
diff --git a/frontend/src/hooks/queryBuilder/useGetCompositeQueryParam.ts b/frontend/src/hooks/queryBuilder/useGetCompositeQueryParam.ts
index 442531a15b..efef00022a 100644
--- a/frontend/src/hooks/queryBuilder/useGetCompositeQueryParam.ts
+++ b/frontend/src/hooks/queryBuilder/useGetCompositeQueryParam.ts
@@ -13,7 +13,11 @@ export const useGetCompositeQueryParam = (): Query | null => {
try {
if (!compositeQuery) return null;
- parsedCompositeQuery = JSON.parse(decodeURIComponent(compositeQuery));
+ // MDN reference - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#decoding_query_parameters_from_a_url
+ // MDN reference to support + characters using encoding - https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams#preserving_plus_signs add later
+ parsedCompositeQuery = JSON.parse(
+ decodeURIComponent(compositeQuery.replace(/\+/g, ' ')),
+ );
} catch (e) {
parsedCompositeQuery = null;
}
diff --git a/frontend/src/index.html.ejs b/frontend/src/index.html.ejs
index 8a4e407ec5..f77e50f2b2 100644
--- a/frontend/src/index.html.ejs
+++ b/frontend/src/index.html.ejs
@@ -114,25 +114,6 @@
})();
-
-