alerting: fix a bunch of lint issues. (#17128)

pkg/services/alerting/engine.go

@@ -17,44 +17,43 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
+// AlertingService is the background process that
+// schedules alert evaluations and makes sure notifications
+// are sent.
 type AlertingService struct {
 	RenderService rendering.Service `inject:""`
 
-	execQueue chan *Job
-	//clock         clock.Clock
+	execQueue     chan *Job
 	ticker        *Ticker
-	scheduler     Scheduler
-	evalHandler   EvalHandler
-	ruleReader    RuleReader
+	scheduler     scheduler
+	evalHandler   evalHandler
+	ruleReader    ruleReader
 	log           log.Logger
-	resultHandler ResultHandler
+	resultHandler resultHandler
 }
 
 func init() {
 	registry.RegisterService(&AlertingService{})
 }
 
-func NewEngine() *AlertingService {
-	e := &AlertingService{}
-	e.Init()
-	return e
-}
-
+// IsDisabled returns true if the alerting service is disable for this instance.
 func (e *AlertingService) IsDisabled() bool {
 	return !setting.AlertingEnabled || !setting.ExecuteAlerts
 }
 
+// Init initalizes the AlertingService.
 func (e *AlertingService) Init() error {
 	e.ticker = NewTicker(time.Now(), time.Second*0, clock.New())
 	e.execQueue = make(chan *Job, 1000)
-	e.scheduler = NewScheduler()
+	e.scheduler = newScheduler()
 	e.evalHandler = NewEvalHandler()
-	e.ruleReader = NewRuleReader()
+	e.ruleReader = newRuleReader()
 	e.log = log.New("alerting.engine")
-	e.resultHandler = NewResultHandler(e.RenderService)
+	e.resultHandler = newResultHandler(e.RenderService)
 	return nil
 }
 
+// Run starts the alerting service background process.
 func (e *AlertingService) Run(ctx context.Context) error {
 	alertGroup, ctx := errgroup.WithContext(ctx)
 	alertGroup.Go(func() error { return e.alertingTicker(ctx) })
@@ -80,7 +79,7 @@ func (e *AlertingService) alertingTicker(grafanaCtx context.Context) error {
 		case tick := <-e.ticker.C:
 			// TEMP SOLUTION update rules ever tenth tick
 			if tickIndex%10 == 0 {
-				e.scheduler.Update(e.ruleReader.Fetch())
+				e.scheduler.Update(e.ruleReader.fetch())
 			}
 
 			e.scheduler.Tick(tick, e.execQueue)
@@ -211,7 +210,7 @@ func (e *AlertingService) processJob(attemptID int, attemptChan chan int, cancel
 		// dont reuse the evalContext and get its own context.
 		evalContext.Ctx = resultHandleCtx
 		evalContext.Rule.State = evalContext.GetNewState()
-		e.resultHandler.Handle(evalContext)
+		e.resultHandler.handle(evalContext)
 		span.Finish()
 		e.log.Debug("Job Execution completed", "timeMs", evalContext.GetDurationMs(), "alertId", evalContext.Rule.Id, "name", evalContext.Rule.Name, "firing", evalContext.Firing, "attemptID", attemptID)
 		close(attemptChan)