github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/segment/results/mresults/metricsresults_test.go (about)

     1  /*
     2  Copyright 2023.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package mresults
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/siglens/siglens/pkg/common/dtypeutils"
    23  	"github.com/siglens/siglens/pkg/segment/structs"
    24  	"github.com/siglens/siglens/pkg/segment/utils"
    25  	"github.com/stretchr/testify/assert"
    26  	"github.com/valyala/bytebufferpool"
    27  )
    28  
    29  func Test_GetResults_AggFn_Sum(t *testing.T) {
    30  	mQuery := &structs.MetricsQuery{
    31  		MetricName: "test.metric.0",
    32  		Aggregator: structs.Aggreation{AggregatorFunction: utils.Sum},
    33  		Downsampler: structs.Downsampler{
    34  			Interval:   3,
    35  			Unit:       "h",
    36  			CFlag:      false,
    37  			Aggregator: structs.Aggreation{AggregatorFunction: utils.Sum},
    38  		},
    39  		TagsFilters: []*structs.TagsFilter{
    40  			{
    41  				TagKey:      "color",
    42  				RawTagValue: "yellow`",
    43  			},
    44  		},
    45  	}
    46  	qid := uint64(0)
    47  	metricsResults := InitMetricResults(mQuery, qid)
    48  	assert.NotNil(t, metricsResults)
    49  
    50  	var tsGroupId *bytebufferpool.ByteBuffer = bytebufferpool.Get()
    51  	defer bytebufferpool.Put(tsGroupId)
    52  	_, err := tsGroupId.Write([]byte("yellow`"))
    53  	assert.NoError(t, err)
    54  	series := InitSeriesHolder(mQuery, tsGroupId)
    55  
    56  	// they should all downsample to 0
    57  	sum := float64(0)
    58  	for i := 0; i < 10; i++ {
    59  		sum += float64(i)
    60  		series.AddEntry(uint32(i), float64(i))
    61  	}
    62  
    63  	assert.Equal(t, series.GetIdx(), 10)
    64  	tsid := uint64(100)
    65  	metricsResults.AddSeries(series, tsid, tsGroupId)
    66  	assert.Len(t, metricsResults.AllSeries, 1)
    67  	assert.Len(t, metricsResults.DsResults, 0)
    68  	assert.Len(t, metricsResults.Results, 0)
    69  	assert.Equal(t, metricsResults.State, SERIES_READING)
    70  
    71  	metricsResults.DownsampleResults(mQuery.Downsampler, 1)
    72  	assert.Equal(t, metricsResults.State, DOWNSAMPLING)
    73  	assert.Len(t, metricsResults.AllSeries, 0)
    74  	assert.Len(t, metricsResults.DsResults, 1)
    75  	assert.Len(t, metricsResults.Results, 0)
    76  	assert.Contains(t, metricsResults.DsResults, tsGroupId.String())
    77  
    78  	errors := metricsResults.AggregateResults(1)
    79  	assert.Nil(t, errors)
    80  	assert.Len(t, metricsResults.AllSeries, 0)
    81  	assert.Len(t, metricsResults.DsResults, 0)
    82  	assert.Len(t, metricsResults.Results, 1)
    83  	assert.Contains(t, metricsResults.Results, tsGroupId.String())
    84  	retVal := metricsResults.Results[tsGroupId.String()]
    85  	assert.Len(t, retVal, 1)
    86  	assert.Contains(t, retVal, uint32(0))
    87  	assert.Equal(t, retVal[0], sum)
    88  
    89  	mQResponse, err := metricsResults.GetOTSDBResults(mQuery)
    90  	assert.NoError(t, err)
    91  	assert.Equal(t, 1, len(mQResponse))
    92  	assert.Equal(t, 1, len(mQResponse[0].Dps))
    93  	for _, val := range mQResponse[0].Dps {
    94  		assert.Equal(t, sum, val)
    95  	}
    96  }
    97  
    98  func Test_GetResults_AggFn_Avg(t *testing.T) {
    99  	mQuery := &structs.MetricsQuery{
   100  		MetricName: "test.metric.0",
   101  		Aggregator: structs.Aggreation{AggregatorFunction: utils.Avg},
   102  		Downsampler: structs.Downsampler{
   103  			Interval:   1,
   104  			Unit:       "h",
   105  			CFlag:      false,
   106  			Aggregator: structs.Aggreation{AggregatorFunction: utils.Sum},
   107  		},
   108  		TagsFilters: []*structs.TagsFilter{
   109  			{
   110  				TagKey:      "color",
   111  				RawTagValue: "yellow`",
   112  			},
   113  		},
   114  	}
   115  	qid := uint64(0)
   116  	metricsResults := InitMetricResults(mQuery, qid)
   117  	assert.NotNil(t, metricsResults)
   118  
   119  	var tsGroupId *bytebufferpool.ByteBuffer = bytebufferpool.Get()
   120  	defer bytebufferpool.Put(tsGroupId)
   121  	_, err := tsGroupId.Write([]byte("yellow`"))
   122  	assert.NoError(t, err)
   123  	series := InitSeriesHolder(mQuery, tsGroupId)
   124  
   125  	// they should all downsample to i
   126  	avg := float64(0)
   127  	for i := 0; i < 10; i++ {
   128  		avg += float64(i)
   129  		series.AddEntry(uint32(i), float64(i))
   130  	}
   131  	finalAvg := avg // because we have 1 series, with a 1h-sum:avg, the avg does nothing
   132  
   133  	assert.Equal(t, series.GetIdx(), 10)
   134  	tsid := uint64(100)
   135  	metricsResults.AddSeries(series, tsid, tsGroupId)
   136  	assert.Len(t, metricsResults.AllSeries, 1)
   137  	assert.Len(t, metricsResults.DsResults, 0)
   138  	assert.Len(t, metricsResults.Results, 0)
   139  	assert.Equal(t, metricsResults.State, SERIES_READING)
   140  
   141  	metricsResults.DownsampleResults(mQuery.Downsampler, 1)
   142  	assert.Equal(t, metricsResults.State, DOWNSAMPLING)
   143  	assert.Len(t, metricsResults.AllSeries, 0)
   144  	assert.Len(t, metricsResults.DsResults, 1)
   145  	assert.Len(t, metricsResults.Results, 0)
   146  	assert.Contains(t, metricsResults.DsResults, tsGroupId.String())
   147  
   148  	errors := metricsResults.AggregateResults(1)
   149  	assert.Nil(t, errors)
   150  
   151  	assert.Len(t, metricsResults.AllSeries, 0)
   152  	assert.Len(t, metricsResults.DsResults, 0)
   153  	assert.Len(t, metricsResults.Results, 1)
   154  	assert.Contains(t, metricsResults.Results, tsGroupId.String())
   155  	retVal := metricsResults.Results[tsGroupId.String()]
   156  	assert.Len(t, retVal, 1)
   157  	assert.Contains(t, retVal, uint32(0))
   158  	assert.Equal(t, retVal[0], finalAvg)
   159  
   160  	mQResponse, err := metricsResults.GetOTSDBResults(mQuery)
   161  	assert.NoError(t, err)
   162  	assert.Equal(t, 1, len(mQResponse))
   163  	assert.Equal(t, 1, len(mQResponse[0].Dps))
   164  	for _, val := range mQResponse[0].Dps {
   165  		assert.Equal(t, finalAvg, val)
   166  	}
   167  }
   168  
   169  func Test_GetResults_AggFn_Multiple(t *testing.T) {
   170  	var numSeries int = 5
   171  	mQuery := &structs.MetricsQuery{
   172  		MetricName: "test.metric.0",
   173  		Aggregator: structs.Aggreation{AggregatorFunction: utils.Avg},
   174  		Downsampler: structs.Downsampler{
   175  			Interval:   2,
   176  			Unit:       "s",
   177  			CFlag:      false,
   178  			Aggregator: structs.Aggreation{AggregatorFunction: utils.Sum},
   179  		},
   180  		TagsFilters: []*structs.TagsFilter{
   181  			{
   182  				TagKey:      "color",
   183  				RawTagValue: "yellow`",
   184  			},
   185  		},
   186  	}
   187  
   188  	qid := uint64(0)
   189  	metricsResults := InitMetricResults(mQuery, qid)
   190  	assert.NotNil(t, metricsResults)
   191  	dsSec := mQuery.Downsampler.GetIntervalTimeInSeconds()
   192  
   193  	grpId := []byte("yellow`")
   194  	for i := 0; i < numSeries; i++ {
   195  		var tsGroupId *bytebufferpool.ByteBuffer = bytebufferpool.Get()
   196  		defer bytebufferpool.Put(tsGroupId)
   197  		_, err := tsGroupId.Write(grpId)
   198  		assert.NoError(t, err)
   199  		series := InitSeriesHolder(mQuery, tsGroupId)
   200  		for i := 0; i < 10; i++ {
   201  			series.AddEntry(uint32(i), float64(i))
   202  		}
   203  		metricsResults.AddSeries(series, uint64(i), tsGroupId)
   204  	}
   205  	assert.Len(t, metricsResults.AllSeries, numSeries)
   206  	assert.Len(t, metricsResults.DsResults, 0)
   207  	assert.Len(t, metricsResults.Results, 0)
   208  	assert.Equal(t, metricsResults.State, SERIES_READING)
   209  
   210  	metricsResults.DownsampleResults(mQuery.Downsampler, 1)
   211  	assert.Equal(t, metricsResults.State, DOWNSAMPLING)
   212  	assert.Len(t, metricsResults.AllSeries, 0)
   213  	assert.Len(t, metricsResults.DsResults, 1)
   214  	assert.Len(t, metricsResults.Results, 0)
   215  	assert.Contains(t, metricsResults.DsResults, string(grpId))
   216  
   217  	errors := metricsResults.AggregateResults(1)
   218  	assert.Nil(t, errors)
   219  	assert.Len(t, metricsResults.AllSeries, 0)
   220  	assert.Len(t, metricsResults.DsResults, 0)
   221  	assert.Len(t, metricsResults.Results, 1)
   222  	assert.Contains(t, metricsResults.Results, "yellow`")
   223  	retVal := metricsResults.Results["yellow`"]
   224  	for i := uint32(0); i < 10; i++ {
   225  		newTime := ((i / dsSec) * dsSec)
   226  		assert.Contains(t, retVal, newTime)
   227  	}
   228  }
   229  
   230  func Test_GetResults_AggFn_Quantile(t *testing.T) {
   231  	mQuery := &structs.MetricsQuery{
   232  		MetricName: "test.metric.0",
   233  		Aggregator: structs.Aggreation{AggregatorFunction: utils.Quantile, FuncConstant: 0.5},
   234  		Downsampler: structs.Downsampler{
   235  			Interval:   3,
   236  			Unit:       "h",
   237  			CFlag:      false,
   238  			Aggregator: structs.Aggreation{AggregatorFunction: utils.Quantile, FuncConstant: 0.5},
   239  		},
   240  		TagsFilters: []*structs.TagsFilter{
   241  			{
   242  				TagKey:      "color",
   243  				RawTagValue: "yellow`",
   244  			},
   245  		},
   246  	}
   247  	qid := uint64(0)
   248  	metricsResults := InitMetricResults(mQuery, qid)
   249  	assert.NotNil(t, metricsResults)
   250  
   251  	var tsGroupId *bytebufferpool.ByteBuffer = bytebufferpool.Get()
   252  	defer bytebufferpool.Put(tsGroupId)
   253  	_, err := tsGroupId.Write([]byte("yellow`"))
   254  	assert.NoError(t, err)
   255  	series := InitSeriesHolder(mQuery, tsGroupId)
   256  
   257  	// they should all downsample to 0
   258  	sum := float64(0)
   259  	for i := 0; i < 10; i++ {
   260  		sum += float64(i)
   261  		series.AddEntry(uint32(i), float64(i))
   262  	}
   263  
   264  	assert.Equal(t, series.GetIdx(), 10)
   265  	tsid := uint64(100)
   266  	metricsResults.AddSeries(series, tsid, tsGroupId)
   267  	assert.Len(t, metricsResults.AllSeries, 1)
   268  	assert.Len(t, metricsResults.DsResults, 0)
   269  	assert.Len(t, metricsResults.Results, 0)
   270  	assert.Equal(t, metricsResults.State, SERIES_READING)
   271  
   272  	metricsResults.DownsampleResults(mQuery.Downsampler, 1)
   273  	assert.Equal(t, metricsResults.State, DOWNSAMPLING)
   274  	assert.Len(t, metricsResults.AllSeries, 0)
   275  	assert.Len(t, metricsResults.DsResults, 1)
   276  	assert.Len(t, metricsResults.Results, 0)
   277  	assert.Contains(t, metricsResults.DsResults, tsGroupId.String())
   278  
   279  	errors := metricsResults.AggregateResults(1)
   280  	assert.Nil(t, errors)
   281  	assert.Len(t, metricsResults.AllSeries, 0)
   282  	assert.Len(t, metricsResults.DsResults, 0)
   283  	assert.Len(t, metricsResults.Results, 1)
   284  	assert.Contains(t, metricsResults.Results, tsGroupId.String())
   285  	retVal := metricsResults.Results[tsGroupId.String()]
   286  	assert.Len(t, retVal, 1)
   287  	assert.Contains(t, retVal, uint32(0))
   288  	assert.Equal(t, retVal[0], float64(4.5))
   289  
   290  	mQResponse, err := metricsResults.GetOTSDBResults(mQuery)
   291  	assert.NoError(t, err)
   292  	assert.Equal(t, 1, len(mQResponse))
   293  	assert.Equal(t, 1, len(mQResponse[0].Dps))
   294  	for _, val := range mQResponse[0].Dps {
   295  		assert.Equal(t, float64(4.5), val)
   296  	}
   297  }
   298  
   299  func Test_GetResults_AggFn_QuantileFloatIndex(t *testing.T) {
   300  	mQuery := &structs.MetricsQuery{
   301  		MetricName: "test.metric.0",
   302  		Aggregator: structs.Aggreation{AggregatorFunction: utils.Quantile, FuncConstant: 0.3},
   303  		Downsampler: structs.Downsampler{
   304  			Interval:   3,
   305  			Unit:       "h",
   306  			CFlag:      false,
   307  			Aggregator: structs.Aggreation{AggregatorFunction: utils.Quantile, FuncConstant: 0.3},
   308  		},
   309  		TagsFilters: []*structs.TagsFilter{
   310  			{
   311  				TagKey:      "color",
   312  				RawTagValue: "yellow`",
   313  			},
   314  		},
   315  	}
   316  	qid := uint64(0)
   317  	metricsResults := InitMetricResults(mQuery, qid)
   318  	assert.NotNil(t, metricsResults)
   319  
   320  	var tsGroupId *bytebufferpool.ByteBuffer = bytebufferpool.Get()
   321  	defer bytebufferpool.Put(tsGroupId)
   322  	_, err := tsGroupId.Write([]byte("yellow`"))
   323  	assert.NoError(t, err)
   324  	series := InitSeriesHolder(mQuery, tsGroupId)
   325  
   326  	// they should all downsample to 0
   327  	sum := float64(0)
   328  	for i := 0; i < 10; i++ {
   329  		sum += float64(i)
   330  		series.AddEntry(uint32(i), float64(i))
   331  	}
   332  
   333  	assert.Equal(t, series.GetIdx(), 10)
   334  	tsid := uint64(100)
   335  	metricsResults.AddSeries(series, tsid, tsGroupId)
   336  	assert.Len(t, metricsResults.AllSeries, 1)
   337  	assert.Len(t, metricsResults.DsResults, 0)
   338  	assert.Len(t, metricsResults.Results, 0)
   339  	assert.Equal(t, metricsResults.State, SERIES_READING)
   340  
   341  	metricsResults.DownsampleResults(mQuery.Downsampler, 1)
   342  	assert.Equal(t, metricsResults.State, DOWNSAMPLING)
   343  	assert.Len(t, metricsResults.AllSeries, 0)
   344  	assert.Len(t, metricsResults.DsResults, 1)
   345  	assert.Len(t, metricsResults.Results, 0)
   346  	assert.Contains(t, metricsResults.DsResults, tsGroupId.String())
   347  
   348  	errors := metricsResults.AggregateResults(1)
   349  	assert.Nil(t, errors)
   350  	assert.Len(t, metricsResults.AllSeries, 0)
   351  	assert.Len(t, metricsResults.DsResults, 0)
   352  	assert.Len(t, metricsResults.Results, 1)
   353  	assert.Contains(t, metricsResults.Results, tsGroupId.String())
   354  	retVal := metricsResults.Results[tsGroupId.String()]
   355  	assert.Len(t, retVal, 1)
   356  	assert.Contains(t, retVal, uint32(0))
   357  	assert.True(t, dtypeutils.AlmostEquals(retVal[0], float64(2.7)))
   358  
   359  	mQResponse, err := metricsResults.GetOTSDBResults(mQuery)
   360  	assert.NoError(t, err)
   361  	assert.Equal(t, 1, len(mQResponse))
   362  	assert.Equal(t, 1, len(mQResponse[0].Dps))
   363  	for _, val := range mQResponse[0].Dps {
   364  		assert.True(t, dtypeutils.AlmostEquals(val, float64(2.7)))
   365  	}
   366  }