Alerting: Create instanceStore (#33587)

for https://github.com/grafana/alerting-squad/issues/129

pkg/services/ngalert/api/api.go

@@ -42,8 +42,8 @@ type API struct {
 	RouteRegister   routing.RouteRegister
 	DataService     *tsdb.Service
 	Schedule        schedule.ScheduleService
-	Store           store.Store
 	RuleStore       store.RuleStore
+	InstanceStore   store.InstanceStore
 	AlertingStore   store.AlertingStore
 	DataProxy       *datasourceproxy.DatasourceProxyService
 	Alertmanager    Alertmanager

pkg/services/ngalert/models/instance.go

@@ -44,8 +44,8 @@ func (i InstanceStateType) IsValid() bool {
 
 // SaveAlertInstanceCommand is the query for saving a new alert instance.
 type SaveAlertInstanceCommand struct {
-	DefinitionOrgID   int64
+	RuleOrgID         int64
-	DefinitionUID     string
+	RuleUID           string
 	Labels            InstanceLabels
 	State             InstanceStateType
 	LastEvalTime      time.Time
@@ -56,18 +56,18 @@ type SaveAlertInstanceCommand struct {
 // GetAlertInstanceQuery is the query for retrieving/deleting an alert definition by ID.
 // nolint:unused
 type GetAlertInstanceQuery struct {
-	DefinitionOrgID int64
+	RuleOrgID int64
-	DefinitionUID   string
+	RuleUID   string
-	Labels          InstanceLabels
+	Labels    InstanceLabels
 
 	Result *AlertInstance
 }
 
 // ListAlertInstancesQuery is the query list alert Instances.
 type ListAlertInstancesQuery struct {
-	DefinitionOrgID int64 `json:"-"`
+	RuleOrgID int64 `json:"-"`
-	DefinitionUID   string
+	RuleUID   string
-	State           InstanceStateType
+	State     InstanceStateType
 
 	Result []*ListAlertInstancesQueryResult
 }

pkg/services/ngalert/ngalert.go

@@ -65,14 +65,14 @@ func (ng *AlertNG) Init() error {
 	store := store.DBstore{BaseInterval: baseInterval, DefaultIntervalSeconds: defaultIntervalSeconds, SQLStore: ng.SQLStore}
 
 	schedCfg := schedule.SchedulerCfg{
-		C:            clock.New(),
+		C:             clock.New(),
-		BaseInterval: baseInterval,
+		BaseInterval:  baseInterval,
-		Logger:       ng.Log,
+		Logger:        ng.Log,
-		MaxAttempts:  maxAttempts,
+		MaxAttempts:   maxAttempts,
-		Evaluator:    eval.Evaluator{Cfg: ng.Cfg},
+		Evaluator:     eval.Evaluator{Cfg: ng.Cfg},
-		Store:        store,
+		InstanceStore: store,
-		RuleStore:    store,
+		RuleStore:     store,
-		Notifier:     ng.Alertmanager,
+		Notifier:      ng.Alertmanager,
 	}
 	ng.schedule = schedule.NewScheduler(schedCfg, ng.DataService)
 
@@ -83,7 +83,7 @@ func (ng *AlertNG) Init() error {
 		DataService:     ng.DataService,
 		Schedule:        ng.schedule,
 		DataProxy:       ng.DataProxy,
-		Store:           store,
+		InstanceStore:   store,
 		RuleStore:       store,
 		AlertingStore:   store,
 		Alertmanager:    ng.Alertmanager,

pkg/services/ngalert/schedule/schedule.go

@@ -146,10 +146,10 @@ type schedule struct {
 
 	evaluator eval.Evaluator
 
-	store store.Store
-
 	ruleStore store.RuleStore
 
+	instanceStore store.InstanceStore
+
 	dataService *tsdb.Service
 
 	notifier Notifier
@@ -164,8 +164,8 @@ type SchedulerCfg struct {
 	MaxAttempts     int64
 	StopAppliedFunc func(models.AlertRuleKey)
 	Evaluator       eval.Evaluator
-	Store           store.Store
 	RuleStore       store.RuleStore
+	InstanceStore   store.InstanceStore
 	Notifier        Notifier
 }
 
@@ -182,8 +182,8 @@ func NewScheduler(cfg SchedulerCfg, dataService *tsdb.Service) *schedule {
 		evalAppliedFunc: cfg.EvalAppliedFunc,
 		stopAppliedFunc: cfg.StopAppliedFunc,
 		evaluator:       cfg.Evaluator,
-		store:           cfg.Store,
 		ruleStore:       cfg.RuleStore,
+		instanceStore:   cfg.InstanceStore,
 		dataService:     dataService,
 		notifier:        cfg.Notifier,
 	}
@@ -321,15 +321,15 @@ func (sch *schedule) saveAlertStates(states []*state.State) {
 	sch.log.Debug("saving alert states", "count", len(states))
 	for _, s := range states {
 		cmd := models.SaveAlertInstanceCommand{
-			DefinitionOrgID:   s.OrgID,
+			RuleOrgID:         s.OrgID,
-			DefinitionUID:     s.AlertRuleUID,
+			RuleUID:           s.AlertRuleUID,
 			Labels:            models.InstanceLabels(s.Labels),
 			State:             models.InstanceStateType(s.State.String()),
 			LastEvalTime:      s.LastEvaluationTime,
 			CurrentStateSince: s.StartsAt,
 			CurrentStateEnd:   s.EndsAt,
 		}
-		err := sch.store.SaveAlertInstance(&cmd)
+		err := sch.instanceStore.SaveAlertInstance(&cmd)
 		if err != nil {
 			sch.log.Error("failed to save alert state", "uid", s.AlertRuleUID, "orgId", s.OrgID, "labels", s.Labels.String(), "state", s.State.String(), "msg", err.Error())
 		}
@@ -341,8 +341,7 @@ func (sch *schedule) WarmStateCache(st *state.Manager) {
 	st.ResetCache()
 
 	orgIdsCmd := models.FetchUniqueOrgIdsQuery{}
-
+	if err := sch.instanceStore.FetchOrgIds(&orgIdsCmd); err != nil {
-	if err := sch.store.FetchOrgIds(&orgIdsCmd); err != nil {
 		sch.log.Error("unable to fetch orgIds", "msg", err.Error())
 	}
 
@@ -363,9 +362,9 @@ func (sch *schedule) WarmStateCache(st *state.Manager) {
 
 		// Get Instances
 		cmd := models.ListAlertInstancesQuery{
-			DefinitionOrgID: orgIdResult.DefinitionOrgID,
+			RuleOrgID: orgIdResult.DefinitionOrgID,
 		}
-		if err := sch.ruleStore.ListAlertInstances(&cmd); err != nil {
+		if err := sch.instanceStore.ListAlertInstances(&cmd); err != nil {
 			sch.log.Error("unable to fetch previous state", "msg", err.Error())
 		}
 

pkg/services/ngalert/store/alert_rule.go

@@ -50,9 +50,6 @@ type RuleStore interface {
 	GetOrgRuleGroups(query *ngmodels.ListOrgRuleGroupsQuery) error
 	UpsertAlertRules([]UpsertRule) error
 	UpdateRuleGroup(UpdateRuleGroupCmd) error
-	GetAlertInstance(*ngmodels.GetAlertInstanceQuery) error
-	ListAlertInstances(cmd *ngmodels.ListAlertInstancesQuery) error
-	SaveAlertInstance(cmd *ngmodels.SaveAlertInstanceCommand) error
 }
 
 func getAlertRuleByUID(sess *sqlstore.DBSession, alertRuleUID string, orgID int64) (*ngmodels.AlertRule, error) {

pkg/services/ngalert/store/instance_database.go

@@ -9,9 +9,15 @@ import (
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 )
 
+type InstanceStore interface {
+	GetAlertInstance(cmd *models.GetAlertInstanceQuery) error
+	ListAlertInstances(cmd *models.ListAlertInstancesQuery) error
+	SaveAlertInstance(cmd *models.SaveAlertInstanceCommand) error
+	FetchOrgIds(cmd *models.FetchUniqueOrgIdsQuery) error
+}
+
 // GetAlertInstance is a handler for retrieving an alert instance based on OrgId, AlertDefintionID, and
 // the hash of the labels.
-// nolint:unused
 func (st DBstore) GetAlertInstance(cmd *models.GetAlertInstanceQuery) error {
 	return st.SQLStore.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
 		instance := models.AlertInstance{}
@@ -28,11 +34,11 @@ func (st DBstore) GetAlertInstance(cmd *models.GetAlertInstanceQuery) error {
 			return err
 		}
 
-		params := append(make([]interface{}, 0), cmd.DefinitionOrgID, cmd.DefinitionUID, hash)
+		params := append(make([]interface{}, 0), cmd.RuleOrgID, cmd.RuleUID, hash)
 
 		has, err := sess.SQL(s.String(), params...).Get(&instance)
 		if !has {
-			return fmt.Errorf("instance not found for labels %v (hash: %v), alert definition %v (org %v)", cmd.Labels, hash, cmd.DefinitionUID, cmd.DefinitionOrgID)
+			return fmt.Errorf("instance not found for labels %v (hash: %v), alert definition %v (org %v)", cmd.Labels, hash, cmd.RuleUID, cmd.RuleOrgID)
 		}
 		if err != nil {
 			return err
@@ -57,10 +63,10 @@ func (st DBstore) ListAlertInstances(cmd *models.ListAlertInstancesQuery) error
 			params = append(params, p...)
 		}
 
-		addToQuery("SELECT alert_instance.*, alert_definition.title AS def_title FROM alert_instance LEFT JOIN alert_definition ON alert_instance.def_org_id = alert_definition.org_id AND alert_instance.def_uid = alert_definition.uid WHERE def_org_id = ?", cmd.DefinitionOrgID)
+		addToQuery("SELECT alert_instance.*, alert_definition.title AS def_title FROM alert_instance LEFT JOIN alert_definition ON alert_instance.def_org_id = alert_definition.org_id AND alert_instance.def_uid = alert_definition.uid WHERE def_org_id = ?", cmd.RuleOrgID)
 
-		if cmd.DefinitionUID != "" {
+		if cmd.RuleUID != "" {
-			addToQuery(` AND def_uid = ?`, cmd.DefinitionUID)
+			addToQuery(` AND def_uid = ?`, cmd.RuleUID)
 		}
 
 		if cmd.State != "" {
@@ -77,7 +83,6 @@ func (st DBstore) ListAlertInstances(cmd *models.ListAlertInstancesQuery) error
 }
 
 // SaveAlertInstance is a handler for saving a new alert instance.
-// nolint:unused
 func (st DBstore) SaveAlertInstance(cmd *models.SaveAlertInstanceCommand) error {
 	return st.SQLStore.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
 		labelTupleJSON, labelsHash, err := cmd.Labels.StringAndHash()
@@ -86,8 +91,8 @@ func (st DBstore) SaveAlertInstance(cmd *models.SaveAlertInstanceCommand) error
 		}
 
 		alertInstance := &models.AlertInstance{
-			RuleOrgID:         cmd.DefinitionOrgID,
+			RuleOrgID:         cmd.RuleOrgID,
-			RuleUID:           cmd.DefinitionUID,
+			RuleUID:           cmd.RuleUID,
 			Labels:            cmd.Labels,
 			LabelsHash:        labelsHash,
 			CurrentState:      cmd.State,

pkg/services/ngalert/tests/instance_database_test.go

@@ -42,18 +42,18 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 	t.Run("can save and read new alert instance", func(t *testing.T) {
 		saveCmd := &models.SaveAlertInstanceCommand{
-			DefinitionOrgID: alertRule1.OrgID,
+			RuleOrgID: alertRule1.OrgID,
-			DefinitionUID:   alertRule1.UID,
+			RuleUID:   alertRule1.UID,
-			State:           models.InstanceStateFiring,
+			State:     models.InstanceStateFiring,
-			Labels:          models.InstanceLabels{"test": "testValue"},
+			Labels:    models.InstanceLabels{"test": "testValue"},
 		}
 		err := dbstore.SaveAlertInstance(saveCmd)
 		require.NoError(t, err)
 
 		getCmd := &models.GetAlertInstanceQuery{
-			DefinitionOrgID: saveCmd.DefinitionOrgID,
+			RuleOrgID: saveCmd.RuleOrgID,
-			DefinitionUID:   saveCmd.DefinitionUID,
+			RuleUID:   saveCmd.RuleUID,
-			Labels:          models.InstanceLabels{"test": "testValue"},
+			Labels:    models.InstanceLabels{"test": "testValue"},
 		}
 
 		err = dbstore.GetAlertInstance(getCmd)
@@ -66,17 +66,17 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 	t.Run("can save and read new alert instance with no labels", func(t *testing.T) {
 		saveCmd := &models.SaveAlertInstanceCommand{
-			DefinitionOrgID: alertRule2.OrgID,
+			RuleOrgID: alertRule2.OrgID,
-			DefinitionUID:   alertRule2.UID,
+			RuleUID:   alertRule2.UID,
-			State:           models.InstanceStateNormal,
+			State:     models.InstanceStateNormal,
-			Labels:          models.InstanceLabels{},
+			Labels:    models.InstanceLabels{},
 		}
 		err := dbstore.SaveAlertInstance(saveCmd)
 		require.NoError(t, err)
 
 		getCmd := &models.GetAlertInstanceQuery{
-			DefinitionOrgID: saveCmd.DefinitionOrgID,
+			RuleOrgID: saveCmd.RuleOrgID,
-			DefinitionUID:   saveCmd.DefinitionUID,
+			RuleUID:   saveCmd.RuleUID,
 		}
 
 		err = dbstore.GetAlertInstance(getCmd)
@@ -89,27 +89,27 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 	t.Run("can save two instances with same org_id, uid and different labels", func(t *testing.T) {
 		saveCmdOne := &models.SaveAlertInstanceCommand{
-			DefinitionOrgID: alertRule3.OrgID,
+			RuleOrgID: alertRule3.OrgID,
-			DefinitionUID:   alertRule3.UID,
+			RuleUID:   alertRule3.UID,
-			State:           models.InstanceStateFiring,
+			State:     models.InstanceStateFiring,
-			Labels:          models.InstanceLabels{"test": "testValue"},
+			Labels:    models.InstanceLabels{"test": "testValue"},
 		}
 
 		err := dbstore.SaveAlertInstance(saveCmdOne)
 		require.NoError(t, err)
 
 		saveCmdTwo := &models.SaveAlertInstanceCommand{
-			DefinitionOrgID: saveCmdOne.DefinitionOrgID,
+			RuleOrgID: saveCmdOne.RuleOrgID,
-			DefinitionUID:   saveCmdOne.DefinitionUID,
+			RuleUID:   saveCmdOne.RuleUID,
-			State:           models.InstanceStateFiring,
+			State:     models.InstanceStateFiring,
-			Labels:          models.InstanceLabels{"test": "meow"},
+			Labels:    models.InstanceLabels{"test": "meow"},
 		}
 		err = dbstore.SaveAlertInstance(saveCmdTwo)
 		require.NoError(t, err)
 
 		listQuery := &models.ListAlertInstancesQuery{
-			DefinitionOrgID: saveCmdOne.DefinitionOrgID,
+			RuleOrgID: saveCmdOne.RuleOrgID,
-			DefinitionUID:   saveCmdOne.DefinitionUID,
+			RuleUID:   saveCmdOne.RuleUID,
 		}
 
 		err = dbstore.ListAlertInstances(listQuery)
@@ -120,7 +120,7 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 	t.Run("can list all added instances in org", func(t *testing.T) {
 		listQuery := &models.ListAlertInstancesQuery{
-			DefinitionOrgID: orgID,
+			RuleOrgID: orgID,
 		}
 
 		err := dbstore.ListAlertInstances(listQuery)
@@ -131,8 +131,8 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 	t.Run("can list all added instances in org filtered by current state", func(t *testing.T) {
 		listQuery := &models.ListAlertInstancesQuery{
-			DefinitionOrgID: orgID,
+			RuleOrgID: orgID,
-			State:           models.InstanceStateNormal,
+			State:     models.InstanceStateNormal,
 		}
 
 		err := dbstore.ListAlertInstances(listQuery)
@@ -143,27 +143,27 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 	t.Run("update instance with same org_id, uid and different labels", func(t *testing.T) {
 		saveCmdOne := &models.SaveAlertInstanceCommand{
-			DefinitionOrgID: alertRule4.OrgID,
+			RuleOrgID: alertRule4.OrgID,
-			DefinitionUID:   alertRule4.UID,
+			RuleUID:   alertRule4.UID,
-			State:           models.InstanceStateFiring,
+			State:     models.InstanceStateFiring,
-			Labels:          models.InstanceLabels{"test": "testValue"},
+			Labels:    models.InstanceLabels{"test": "testValue"},
 		}
 
 		err := dbstore.SaveAlertInstance(saveCmdOne)
 		require.NoError(t, err)
 
 		saveCmdTwo := &models.SaveAlertInstanceCommand{
-			DefinitionOrgID: saveCmdOne.DefinitionOrgID,
+			RuleOrgID: saveCmdOne.RuleOrgID,
-			DefinitionUID:   saveCmdOne.DefinitionUID,
+			RuleUID:   saveCmdOne.RuleUID,
-			State:           models.InstanceStateNormal,
+			State:     models.InstanceStateNormal,
-			Labels:          models.InstanceLabels{"test": "testValue"},
+			Labels:    models.InstanceLabels{"test": "testValue"},
 		}
 		err = dbstore.SaveAlertInstance(saveCmdTwo)
 		require.NoError(t, err)
 
 		listQuery := &models.ListAlertInstancesQuery{
-			DefinitionOrgID: alertRule4.OrgID,
+			RuleOrgID: alertRule4.OrgID,
-			DefinitionUID:   alertRule4.UID,
+			RuleUID:   alertRule4.UID,
 		}
 
 		err = dbstore.ListAlertInstances(listQuery)
@@ -171,8 +171,8 @@ func TestAlertInstanceOperations(t *testing.T) {
 
 		require.Len(t, listQuery.Result, 1)
 
-		require.Equal(t, saveCmdTwo.DefinitionOrgID, listQuery.Result[0].RuleOrgID)
+		require.Equal(t, saveCmdTwo.RuleOrgID, listQuery.Result[0].RuleOrgID)
-		require.Equal(t, saveCmdTwo.DefinitionUID, listQuery.Result[0].RuleDefinitionUID)
+		require.Equal(t, saveCmdTwo.RuleUID, listQuery.Result[0].RuleDefinitionUID)
 		require.Equal(t, saveCmdTwo.Labels, listQuery.Result[0].Labels)
 		require.Equal(t, saveCmdTwo.State, listQuery.Result[0].CurrentState)
 	})

pkg/services/ngalert/tests/schedule_test.go

@@ -69,8 +69,8 @@ func TestWarmStateCache(t *testing.T) {
 	}
 
 	saveCmd1 := &models.SaveAlertInstanceCommand{
-		DefinitionOrgID:   rule.OrgID,
+		RuleOrgID:         rule.OrgID,
-		DefinitionUID:     rule.UID,
+		RuleUID:           rule.UID,
 		Labels:            models.InstanceLabels{"test1": "testValue1"},
 		State:             models.InstanceStateNormal,
 		LastEvalTime:      evaluationTime,
@@ -81,8 +81,8 @@ func TestWarmStateCache(t *testing.T) {
 	_ = dbstore.SaveAlertInstance(saveCmd1)
 
 	saveCmd2 := &models.SaveAlertInstanceCommand{
-		DefinitionOrgID:   rule.OrgID,
+		RuleOrgID:         rule.OrgID,
-		DefinitionUID:     rule.UID,
+		RuleUID:           rule.UID,
 		Labels:            models.InstanceLabels{"test2": "testValue2"},
 		State:             models.InstanceStateFiring,
 		LastEvalTime:      evaluationTime,
@@ -97,8 +97,9 @@ func TestWarmStateCache(t *testing.T) {
 		C:            clock.NewMock(),
 		BaseInterval: time.Second,
 		Logger:       log.New("ngalert cache warming test"),
-		Store:        dbstore,
+
-		RuleStore:    dbstore,
+		RuleStore:     dbstore,
+		InstanceStore: dbstore,
 	}
 	sched := schedule.NewScheduler(schedCfg, nil)
 	st := state.NewManager(schedCfg.Logger, nilMetrics)
@@ -143,9 +144,9 @@ func TestAlertingTicker(t *testing.T) {
 		StopAppliedFunc: func(alertDefKey models.AlertRuleKey) {
 			stopAppliedCh <- alertDefKey
 		},
-		Store:     dbstore,
+		RuleStore:     dbstore,
-		RuleStore: dbstore,
+		InstanceStore: dbstore,
-		Logger:    log.New("ngalert schedule test"),
+		Logger:        log.New("ngalert schedule test"),
 	}
 	sched := schedule.NewScheduler(schedCfg, nil)