func (expr *metricFetchExpression) Evaluate(context function.EvaluationContext) (function.Value, error) { // Merge predicates appropriately var predicate api.Predicate if context.Predicate == nil && expr.predicate == nil { predicate = api.TruePredicate } else if context.Predicate == nil { predicate = expr.predicate } else if expr.predicate == nil { predicate = context.Predicate } else { predicate = &andPredicate{[]api.Predicate{expr.predicate, context.Predicate}} } metricTagSets, err := context.API.GetAllTags(api.MetricKey(expr.metricName)) if err != nil { return nil, err } filtered := applyPredicates(metricTagSets, predicate) ok := context.FetchLimit.Consume(len(filtered)) if !ok { return nil, function.NewLimitError("fetch limit exceeded: too many series to fetch", context.FetchLimit.Current(), context.FetchLimit.Limit()) } metrics := make([]api.TaggedMetric, len(filtered)) for i := range metrics { metrics[i] = api.TaggedMetric{api.MetricKey(expr.metricName), filtered[i]} } serieslist, err := context.MultiBackend.FetchMultipleSeries( api.FetchMultipleRequest{ metrics, context.SampleMethod, context.Timerange, context.API, context.Cancellable, context.Profiler, }, ) if err != nil { return nil, err } serieslist.Name = expr.metricName return serieslist, nil }
// Execute performs the query represented by the given query string, and returs the result. func (cmd *SelectCommand) Execute(context ExecutionContext) (interface{}, error) { timerange, err := api.NewSnappedTimerange(cmd.context.Start, cmd.context.End, cmd.context.Resolution) if err != nil { return nil, err } slotLimit := context.SlotLimit defaultLimit := 1000 if slotLimit == 0 { slotLimit = defaultLimit // the default limit } smallestResolution := timerange.Duration() / time.Duration(slotLimit-2) // ((end + res/2) - (start - res/2)) / res + 1 <= slots // make adjustments for a snap that moves the endpoints // (do some algebra) // (end - start + res) + res <= slots * res // end - start <= res * (slots - 2) // so // res >= (end - start) / (slots - 2) // Update the timerange by applying the insights of the storage API: chosenResolution := context.TimeseriesStorageAPI.ChooseResolution(timerange, smallestResolution) chosenTimerange, err := api.NewSnappedTimerange(timerange.Start(), timerange.End(), int64(chosenResolution/time.Millisecond)) if err != nil { return nil, err } if chosenTimerange.Slots() > slotLimit { return nil, function.NewLimitError( "Requested number of data points exceeds the configured limit", chosenTimerange.Slots(), slotLimit) } hasTimeout := context.Timeout != 0 var cancellable api.Cancellable if hasTimeout { cancellable = api.NewTimeoutCancellable(time.Now().Add(context.Timeout)) } else { cancellable = api.NewCancellable() } r := context.Registry if r == nil { r = registry.Default() } defer close(cancellable.Done()) // broadcast the finish - this ensures that the future work is cancelled. evaluationContext := function.EvaluationContext{ MetricMetadataAPI: context.MetricMetadataAPI, FetchLimit: function.NewFetchCounter(context.FetchLimit), TimeseriesStorageAPI: context.TimeseriesStorageAPI, Predicate: cmd.predicate, SampleMethod: cmd.context.SampleMethod, Timerange: timerange, Cancellable: cancellable, Registry: r, Profiler: context.Profiler, OptimizationConfiguration: context.OptimizationConfiguration, } if hasTimeout { timeout := time.After(context.Timeout) results := make(chan interface{}) errors := make(chan error) go func() { result, err := function.EvaluateMany(evaluationContext, cmd.expressions) if err != nil { errors <- err } else { results <- result } }() select { case <-timeout: return nil, function.NewLimitError("Timeout while executing the query.", context.Timeout, context.Timeout) case result := <-results: return result, nil case err := <-errors: return nil, err } } else { values, err := function.EvaluateMany(evaluationContext, cmd.expressions) if err != nil { return nil, err } lists := make([]api.SeriesList, len(values)) for i := range values { lists[i], err = values[i].ToSeriesList(evaluationContext.Timerange) if err != nil { return nil, err } } return lists, nil } }
// Execute performs the query represented by the given query string, and returs the result. func (cmd *SelectCommand) Execute(context ExecutionContext) (interface{}, error) { timerange, err := api.NewSnappedTimerange(cmd.context.Start, cmd.context.End, cmd.context.Resolution) if err != nil { return nil, err } slotLimit := context.SlotLimit defaultLimit := 1000 if slotLimit == 0 { slotLimit = defaultLimit // the default limit } if timerange.Slots() > slotLimit { return nil, function.NewLimitError( "Requested number of data points exceeds the configured limit", timerange.Slots(), slotLimit) } hasTimeout := context.Timeout != 0 var cancellable api.Cancellable if hasTimeout { cancellable = api.NewTimeoutCancellable(time.Now().Add(context.Timeout)) } else { cancellable = api.NewCancellable() } r := context.Registry if r == nil { r = registry.Default() } defer close(cancellable.Done()) // broadcast the finish - this ensures that the future work is cancelled. evaluationContext := function.EvaluationContext{ API: context.API, FetchLimit: function.NewFetchCounter(context.FetchLimit), MultiBackend: context.Backend, Predicate: cmd.predicate, SampleMethod: cmd.context.SampleMethod, Timerange: timerange, Cancellable: cancellable, Profiler: context.Profiler, Registry: r, } if hasTimeout { timeout := time.After(context.Timeout) results := make(chan interface{}) errors := make(chan error) go func() { result, err := function.EvaluateMany(evaluationContext, cmd.expressions) if err != nil { errors <- err } else { results <- result } }() select { case <-timeout: return nil, function.NewLimitError("Timeout while executing the query.", context.Timeout, context.Timeout) case result := <-results: return result, nil case err := <-errors: return nil, err } } else { values, err := function.EvaluateMany(evaluationContext, cmd.expressions) if err != nil { return nil, err } lists := make([]api.SeriesList, len(values)) for i := range values { lists[i], err = values[i].ToSeriesList(evaluationContext.Timerange) if err != nil { return nil, err } } return lists, nil } }
func (expr *metricFetchExpression) Evaluate(context *function.EvaluationContext) (function.Value, error) { // Merge predicates appropriately var predicate api.Predicate if context.Predicate == nil && expr.predicate == nil { predicate = api.TruePredicate } else if context.Predicate == nil { predicate = expr.predicate } else if expr.predicate == nil { predicate = context.Predicate } else { predicate = &andPredicate{[]api.Predicate{expr.predicate, context.Predicate}} } updateFunction := func() ([]api.TagSet, error) { metricTagSets, err := context.MetricMetadataAPI.GetAllTags(api.MetricKey(expr.metricName), api.MetricMetadataAPIContext{ Profiler: context.Profiler, }) if err != nil { return nil, err } return metricTagSets, nil } metricTagSets, err := context.OptimizationConfiguration.AllTagsCacheHitOrExecute(api.MetricKey(expr.metricName), updateFunction) if err != nil { return nil, err } filtered := applyPredicates(metricTagSets, predicate) ok := context.FetchLimit.Consume(len(filtered)) if !ok { return nil, function.NewLimitError("fetch limit exceeded: too many series to fetch", context.FetchLimit.Current(), context.FetchLimit.Limit()) } metrics := make([]api.TaggedMetric, len(filtered)) for i := range metrics { metrics[i] = api.TaggedMetric{api.MetricKey(expr.metricName), filtered[i]} } serieslist, err := context.TimeseriesStorageAPI.FetchMultipleTimeseries( api.FetchMultipleTimeseriesRequest{ metrics, context.SampleMethod, context.Timerange, context.MetricMetadataAPI, context.Cancellable, context.Profiler, context.UserSpecifiableConfig, }, ) if err != nil { return nil, err } serieslist.Name = expr.metricName serieslist.Query = expr.metricName return serieslist, nil }
// Execute performs the query represented by the given query string, and returs the result. func (cmd *SelectCommand) Execute(context ExecutionContext) (CommandResult, error) { userTimerange, err := api.NewSnappedTimerange(cmd.context.Start, cmd.context.End, cmd.context.Resolution) if err != nil { return CommandResult{}, err } slotLimit := context.SlotLimit defaultLimit := 1000 if slotLimit == 0 { slotLimit = defaultLimit // the default limit } smallestResolution := userTimerange.Duration() / time.Duration(slotLimit-2) // ((end + res/2) - (start - res/2)) / res + 1 <= slots // make adjustments for a snap that moves the endpoints // (do some algebra) // (end - start + res) + res <= slots * res // end - start <= res * (slots - 2) // so // res >= (end - start) / (slots - 2) // Update the timerange by applying the insights of the storage API: chosenResolution := context.TimeseriesStorageAPI.ChooseResolution(userTimerange, smallestResolution) chosenTimerange, err := api.NewSnappedTimerange(userTimerange.Start(), userTimerange.End(), int64(chosenResolution/time.Millisecond)) if err != nil { return CommandResult{}, err } if chosenTimerange.Slots() > slotLimit { return CommandResult{}, function.NewLimitError( "Requested number of data points exceeds the configured limit", chosenTimerange.Slots(), slotLimit) } hasTimeout := context.Timeout != 0 var cancellable api.Cancellable if hasTimeout { cancellable = api.NewTimeoutCancellable(time.Now().Add(context.Timeout)) } else { cancellable = api.NewCancellable() } r := context.Registry if r == nil { r = registry.Default() } defer close(cancellable.Done()) // broadcast the finish - this ensures that the future work is cancelled. evaluationContext := function.EvaluationContext{ MetricMetadataAPI: context.MetricMetadataAPI, FetchLimit: function.NewFetchCounter(context.FetchLimit), TimeseriesStorageAPI: context.TimeseriesStorageAPI, Predicate: cmd.predicate, SampleMethod: cmd.context.SampleMethod, Timerange: chosenTimerange, Cancellable: cancellable, Registry: r, Profiler: context.Profiler, OptimizationConfiguration: context.OptimizationConfiguration, EvaluationNotes: []string{}, UserSpecifiableConfig: context.UserSpecifiableConfig, } timeout := (<-chan time.Time)(nil) if hasTimeout { // A nil channel will just block forever timeout = time.After(context.Timeout) } results := make(chan []function.Value, 1) errors := make(chan error, 1) // Goroutines are never garbage collected, so we need to provide capacity so that the send always succeeds. go func() { // Evaluate the result, and send it along the goroutines. result, err := function.EvaluateMany(&evaluationContext, cmd.expressions) if err != nil { errors <- err return } results <- result }() select { case <-timeout: return CommandResult{}, function.NewLimitError("Timeout while executing the query.", context.Timeout, context.Timeout) case err := <-errors: return CommandResult{}, err case result := <-results: lists := make([]api.SeriesList, len(result)) for i := range result { lists[i], err = result[i].ToSeriesList(evaluationContext.Timerange) if err != nil { return CommandResult{}, err } } description := map[string][]string{} for _, list := range lists { for _, series := range list.Series { for key, value := range series.TagSet { description[key] = append(description[key], value) } } } for key, values := range description { natural_sort.Sort(values) filtered := []string{} for i := range values { if i == 0 || values[i-1] != values[i] { filtered = append(filtered, values[i]) } } description[key] = filtered } return CommandResult{ Body: lists, Metadata: map[string]interface{}{ "description": description, "notes": evaluationContext.EvaluationNotes, }, }, nil } }