Alerting: Simplify scheduler configuration and remove dependency on Grafana-wide settings (#59735)

* Make scheduler not depend directly on grafana-wide settings

* Re-add missing interval

pkg/services/ngalert/schedule/schedule.go

@@ -18,7 +18,6 @@ import (
 	"github.com/grafana/grafana/pkg/services/ngalert/state"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/user"
-	"github.com/grafana/grafana/pkg/setting"
 	"github.com/grafana/grafana/pkg/util/ticker"
 
 	"github.com/benbjohnson/clock"
@@ -98,29 +97,33 @@ type schedule struct {
 
 // SchedulerCfg is the scheduler configuration.
 type SchedulerCfg struct {
-	Cfg              setting.UnifiedAlertingSettings
-	C                clock.Clock
-	EvaluatorFactory eval.EvaluatorFactory
-	RuleStore        RulesStore
-	Metrics          *metrics.Scheduler
-	AlertSender      AlertsSender
+	MaxAttempts          int64
+	BaseInterval         time.Duration
+	C                    clock.Clock
+	MinRuleInterval      time.Duration
+	DisableGrafanaFolder bool
+	AppURL               *url.URL
+	EvaluatorFactory     eval.EvaluatorFactory
+	RuleStore            RulesStore
+	Metrics              *metrics.Scheduler
+	AlertSender          AlertsSender
 }
 
 // NewScheduler returns a new schedule.
-func NewScheduler(cfg SchedulerCfg, appURL *url.URL, stateManager *state.Manager) *schedule {
+func NewScheduler(cfg SchedulerCfg, stateManager *state.Manager) *schedule {
 	sch := schedule{
 		registry:              alertRuleInfoRegistry{alertRuleInfo: make(map[ngmodels.AlertRuleKey]*alertRuleInfo)},
-		maxAttempts:           cfg.Cfg.MaxAttempts,
+		maxAttempts:           cfg.MaxAttempts,
 		clock:                 cfg.C,
-		baseInterval:          cfg.Cfg.BaseInterval,
+		baseInterval:          cfg.BaseInterval,
 		log:                   log.New("ngalert.scheduler"),
 		evaluatorFactory:      cfg.EvaluatorFactory,
 		ruleStore:             cfg.RuleStore,
 		metrics:               cfg.Metrics,
-		appURL:                appURL,
-		disableGrafanaFolder:  cfg.Cfg.ReservedLabels.IsReservedLabelDisabled(ngmodels.FolderTitleLabel),
+		appURL:                cfg.AppURL,
+		disableGrafanaFolder:  cfg.DisableGrafanaFolder,
 		stateManager:          stateManager,
-		minRuleInterval:       cfg.Cfg.MinInterval,
+		minRuleInterval:       cfg.MinRuleInterval,
 		schedulableAlertRules: alertRulesRegistry{rules: make(map[ngmodels.AlertRuleKey]*ngmodels.AlertRule)},
 		alertsSender:          cfg.AlertSender,
 	}

pkg/services/ngalert/schedule/schedule_unit_test.go

@@ -54,20 +54,22 @@ func TestProcessTicks(t *testing.T) {
 	notifier := &AlertsSenderMock{}
 	notifier.EXPECT().Send(mock.Anything, mock.Anything).Return()
 
-	schedCfg := SchedulerCfg{
-		Cfg:         cfg,
-		C:           mockedClock,
-		RuleStore:   ruleStore,
-		Metrics:     testMetrics.GetSchedulerMetrics(),
-		AlertSender: notifier,
-	}
-	st := state.NewManager(testMetrics.GetStateMetrics(), nil, nil, &state.NoopImageService{}, mockedClock, &state.FakeHistorian{})
-
 	appUrl := &url.URL{
 		Scheme: "http",
 		Host:   "localhost",
 	}
-	sched := NewScheduler(schedCfg, appUrl, st)
+
+	schedCfg := SchedulerCfg{
+		BaseInterval: cfg.BaseInterval,
+		C:            mockedClock,
+		AppURL:       appUrl,
+		RuleStore:    ruleStore,
+		Metrics:      testMetrics.GetSchedulerMetrics(),
+		AlertSender:  notifier,
+	}
+	st := state.NewManager(testMetrics.GetStateMetrics(), nil, nil, &state.NoopImageService{}, mockedClock, &state.FakeHistorian{})
+
+	sched := NewScheduler(schedCfg, st)
 
 	evalAppliedCh := make(chan evalAppliedInfo, 1)
 	stopAppliedCh := make(chan models.AlertRuleKey, 1)
@@ -673,8 +675,10 @@ func setupScheduler(t *testing.T, rs *fakeRulesStore, is *state.FakeInstanceStor
 	}
 
 	schedCfg := SchedulerCfg{
-		Cfg:              cfg,
+		BaseInterval:     cfg.BaseInterval,
+		MaxAttempts:      cfg.MaxAttempts,
 		C:                mockedClock,
+		AppURL:           appUrl,
 		EvaluatorFactory: evaluator,
 		RuleStore:        rs,
 		Metrics:          m.GetSchedulerMetrics(),
@@ -682,7 +686,7 @@ func setupScheduler(t *testing.T, rs *fakeRulesStore, is *state.FakeInstanceStor
 	}
 
 	st := state.NewManager(m.GetStateMetrics(), nil, is, &state.NoopImageService{}, mockedClock, &state.FakeHistorian{})
-	return NewScheduler(schedCfg, appUrl, st)
+	return NewScheduler(schedCfg, st)
 }
 
 func withQueryForState(t *testing.T, evalResult eval.State) models.AlertRuleMutator {