func NewPromqlExecutor()

in clusterloader2/pkg/measurement/common/executors/promql_executor.go [90:147]
46 lines of code
11 McCabe index (conditional complexity)

func NewPromqlExecutor(timeSeriesFile string) (*PromqlExecutor, error) {
	//Load time series from file
	f, err := loadFromFile(timeSeriesFile)
	if err != nil {
		return nil, fmt.Errorf("could not parse time series file: %v", err)
	}

	interval, err := time.ParseDuration(f.Interval)
	if err != nil {
		return nil, fmt.Errorf("could not parse interval from time series file: %v", err)
	}

	ll, err := promql.NewLazyLoader(nil, f.seriesLoadingString())
	if err != nil {
		return nil, fmt.Errorf("could not initialize lazy loader: %v", err)
	}

	//Load rule groups
	opts := &rules.ManagerOptions{
		QueryFunc:  rules.EngineQueryFunc(ll.QueryEngine(), ll.Storage()),
		Appendable: ll.Storage(),
		Context:    context.Background(),
		NotifyFunc: func(ctx context.Context, expr string, alerts ...*rules.Alert) {},
		Logger:     nil,
	}
	m := rules.NewManager(opts)

	rulesFile, err := createRulesFile(os.ExpandEnv(pathToPrometheusRules))
	if err != nil {
		return nil, fmt.Errorf("could not create rules file: %v", err)
	}
	defer os.Remove(rulesFile.Name())
	groupsMap, ers := m.LoadGroups(interval, nil, rulesFile.Name())
	if ers != nil {
		return nil, fmt.Errorf("could not load rules file: %v", ers)
	}

	//Load data into ll
	ll.WithSamplesTill(time.Now(), func(e error) {
		if err != nil {
			err = e
		}
	})
	if err != nil {
		return nil, fmt.Errorf("could not load samples into lazyloader: %v", err)
	}

	// Evaluate rules after data was loaded
	// This assumes that no one will try to load time series longer than 6 hours
	maxt := time.Unix(0, 0).UTC().Add(time.Duration(6*60) * time.Minute)
	for ts := time.Unix(0, 0).UTC(); ts.Before(maxt) || ts.Equal(maxt); ts = ts.Add(interval) {
		for _, g := range groupsMap {
			g.Eval(context.Background(), ts)
		}
	}

	return &PromqlExecutor{ll: *ll, interval: interval}, nil
}