Add state retrieval for alert rules (#87)

* Add state retrieval for alert rules

* Make alerting client and its structs private

Author: alexander-akhmetov

README.md

@@ -29,9 +29,9 @@ This provides access to your Grafana instance and the surrounding ecosystem.
 - [ ] Start Sift investigations and view the results
 - [ ] Alerting
   - [x] List and fetch alert rule information
-  - [ ] Get alert rule statuses (firing/normal/error/etc.)
+  - [x] Get alert rule statuses (firing/normal/error/etc.)
   - [ ] Create and change alert rules
-  - [ ] List contact points
+  - [x] List contact points
   - [ ] Create and change contact points
 - [x] Access Grafana OnCall functionality
   - [x] List and manage schedules

tools/alerting.go

@@ -7,7 +7,6 @@ import (
 	"github.com/grafana/grafana-openapi-client-go/client/provisioning"
 	"github.com/grafana/grafana-openapi-client-go/models"
 	"github.com/mark3labs/mcp-go/server"
-	"github.com/prometheus/prometheus/model/labels"
 
 	mcpgrafana "github.com/grafana/mcp-grafana"
 )
@@ -35,8 +34,11 @@ func (p ListAlertRulesParams) validate() error {
 }
 
 type alertRuleSummary struct {
-	UID    string            `json:"uid"`
-	Title  string            `json:"title"`
+	UID   string `json:"uid"`
+	Title string `json:"title"`
+	// State can be one of: pending, firing, error, recovering, inactive.
+	// "inactive" means the alert state is normal, not firing.
+	State  string            `json:"state"`
 	Labels map[string]string `json:"labels,omitempty"`
 }
 
@@ -45,13 +47,21 @@ func listAlertRules(ctx context.Context, args ListAlertRulesParams) ([]alertRule
 		return nil, fmt.Errorf("list alert rules: %w", err)
 	}
 
-	c := mcpgrafana.GrafanaClientFromContext(ctx)
-	response, err := c.Provisioning.GetAlertRules()
+	c, err := newAlertingClientFromContext(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("list alert rules: %w", err)
+	}
+	response, err := c.GetRules(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("list alert rules: %w", err)
 	}
 
-	alertRules, err := filterAlertRules(response.Payload, args.LabelSelectors)
+	alertRules := []alertingRule{}
+	for _, group := range response.Data.RuleGroups {
+		alertRules = append(alertRules, group.Rules...)
+	}
+
+	alertRules, err = filterAlertRules(alertRules, args.LabelSelectors)
 	if err != nil {
 		return nil, fmt.Errorf("list alert rules: %w", err)
 	}
@@ -65,18 +75,14 @@ func listAlertRules(ctx context.Context, args ListAlertRulesParams) ([]alertRule
 }
 
 // filterAlertRules filters a list of alert rules based on label selectors
-func filterAlertRules(rules models.ProvisionedAlertRules, selectors []Selector) (models.ProvisionedAlertRules, error) {
+func filterAlertRules(rules []alertingRule, selectors []Selector) ([]alertingRule, error) {
 	if len(selectors) == 0 {
 		return rules, nil
 	}
 
-	filteredResult := models.ProvisionedAlertRules{}
+	filteredResult := []alertingRule{}
 	for _, rule := range rules {
-		if rule == nil {
-			continue
-		}
-
-		match, err := matchesSelectors(*rule, selectors)
+		match, err := matchesSelectors(rule, selectors)
 		if err != nil {
 			return nil, fmt.Errorf("filtering alert rules: %w", err)
 		}
@@ -90,11 +96,9 @@ func filterAlertRules(rules models.ProvisionedAlertRules, selectors []Selector)
 }
 
 // matchesSelectors checks if an alert rule matches all provided selectors
-func matchesSelectors(rule models.ProvisionedAlertRule, selectors []Selector) (bool, error) {
-	promLabels := labels.FromMap(rule.Labels)
-
+func matchesSelectors(rule alertingRule, selectors []Selector) (bool, error) {
 	for _, selector := range selectors {
-		match, err := selector.Matches(promLabels)
+		match, err := selector.Matches(rule.Labels)
 		if err != nil {
 			return false, err
 		}
@@ -105,26 +109,22 @@ func matchesSelectors(rule models.ProvisionedAlertRule, selectors []Selector) (b
 	return true, nil
 }
 
-func summarizeAlertRules(alertRules models.ProvisionedAlertRules) []alertRuleSummary {
+func summarizeAlertRules(alertRules []alertingRule) []alertRuleSummary {
 	result := make([]alertRuleSummary, 0, len(alertRules))
 	for _, r := range alertRules {
-		title := ""
-		if r.Title != nil {
-			title = *r.Title
-		}
-
 		result = append(result, alertRuleSummary{
 			UID:    r.UID,
-			Title:  title,
-			Labels: r.Labels,
+			Title:  r.Name,
+			State:  r.State,
+			Labels: r.Labels.Map(),
 		})
 	}
 	return result
 }
 
 // applyPagination applies pagination to the list of alert rules.
 // It doesn't sort the items and relies on the order returned by the API.
-func applyPagination(items models.ProvisionedAlertRules, limit, page int) (models.ProvisionedAlertRules, error) {
+func applyPagination(items []alertingRule, limit, page int) ([]alertingRule, error) {
 	if limit == 0 {
 		limit = DefaultListAlertRulesLimit
 	}
@@ -136,7 +136,7 @@ func applyPagination(items models.ProvisionedAlertRules, limit, page int) (model
 	end := start + limit
 
 	if start >= len(items) {
-		return models.ProvisionedAlertRules{}, nil
+		return nil, nil
 	} else if end > len(items) {
 		return items[start:], nil
 	}
@@ -146,7 +146,7 @@ func applyPagination(items models.ProvisionedAlertRules, limit, page int) (model
 
 var ListAlertRules = mcpgrafana.MustTool(
 	"list_alert_rules",
-	"List alert rules",
+	"Lists alert rules with their current states (pending, firing, error, recovering, inactive) and labels. Inactive state means the alert state is normal, not firing.",
 	listAlertRules,
 )
 
@@ -177,7 +177,7 @@ func getAlertRuleByUID(ctx context.Context, args GetAlertRuleByUIDParams) (*mode
 
 var GetAlertRuleByUID = mcpgrafana.MustTool(
 	"get_alert_rule_by_uid",
-	"Get alert rule by uid",
+	"Retrieves detailed information about a specific alert rule by its UID.",
 	getAlertRuleByUID,
 )
 
@@ -250,7 +250,7 @@ func applyLimitToContactPoints(items []*models.EmbeddedContactPoint, limit int)
 
 var ListContactPoints = mcpgrafana.MustTool(
 	"list_contact_points",
-	"List contact points",
+	"Lists notification contact points with their type, name, and configuration.",
 	listContactPoints,
 )
 

tools/alerting_client.go

@@ -0,0 +1,133 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/prometheus/prometheus/model/labels"
+
+	mcpgrafana "github.com/grafana/mcp-grafana"
+)
+
+const (
+	defaultTimeout    = 30 * time.Second
+	rulesEndpointPath = "/api/prometheus/grafana/api/v1/rules"
+)
+
+type alertingClient struct {
+	baseURL    *url.URL
+	apiKey     string
+	httpClient *http.Client
+}
+
+func newAlertingClientFromContext(ctx context.Context) (*alertingClient, error) {
+	baseURL := strings.TrimRight(mcpgrafana.GrafanaURLFromContext(ctx), "/")
+	parsedBaseURL, err := url.Parse(baseURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid Grafana base URL %q: %w", baseURL, err)
+	}
+
+	return &alertingClient{
+		baseURL: parsedBaseURL,
+		apiKey:  mcpgrafana.GrafanaAPIKeyFromContext(ctx),
+		httpClient: &http.Client{
+			Timeout: defaultTimeout,
+		},
+	}, nil
+}
+
+func (c *alertingClient) makeRequest(ctx context.Context, path string) (*http.Response, error) {
+	p := c.baseURL.JoinPath(path).String()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, p, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request to %s: %w", p, err)
+	}
+
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+
+	if c.apiKey != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.apiKey))
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute request to %s: %w", p, err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		return nil, fmt.Errorf("Grafana API returned status code %d: %s", resp.StatusCode, string(bodyBytes))
+	}
+
+	return resp, nil
+}
+
+func (c *alertingClient) GetRules(ctx context.Context) (*rulesResponse, error) {
+	resp, err := c.makeRequest(ctx, rulesEndpointPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get alert rules from Grafana API: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var rulesResponse rulesResponse
+	decoder := json.NewDecoder(resp.Body)
+	if err := decoder.Decode(&rulesResponse); err != nil {
+		return nil, fmt.Errorf("failed to decode rules response from %s: %w", rulesEndpointPath, err)
+	}
+
+	return &rulesResponse, nil
+}
+
+type rulesResponse struct {
+	Data struct {
+		RuleGroups []ruleGroup      `json:"groups"`
+		NextToken  string           `json:"groupNextToken,omitempty"`
+		Totals     map[string]int64 `json:"totals,omitempty"`
+	} `json:"data"`
+}
+
+type ruleGroup struct {
+	Name           string         `json:"name"`
+	FolderUID      string         `json:"folderUid"`
+	Rules          []alertingRule `json:"rules"`
+	Interval       float64        `json:"interval"`
+	LastEvaluation time.Time      `json:"lastEvaluation"`
+	EvaluationTime float64        `json:"evaluationTime"`
+}
+
+type alertingRule struct {
+	State          string           `json:"state,omitempty"`
+	Name           string           `json:"name,omitempty"`
+	Query          string           `json:"query,omitempty"`
+	Duration       float64          `json:"duration,omitempty"`
+	KeepFiringFor  float64          `json:"keepFiringFor,omitempty"`
+	Annotations    labels.Labels    `json:"annotations,omitempty"`
+	ActiveAt       *time.Time       `json:"activeAt,omitempty"`
+	Alerts         []alert          `json:"alerts,omitempty"`
+	Totals         map[string]int64 `json:"totals,omitempty"`
+	TotalsFiltered map[string]int64 `json:"totalsFiltered,omitempty"`
+	UID            string           `json:"uid"`
+	FolderUID      string           `json:"folderUid"`
+	Labels         labels.Labels    `json:"labels,omitempty"`
+	Health         string           `json:"health"`
+	LastError      string           `json:"lastError,omitempty"`
+	Type           string           `json:"type"`
+	LastEvaluation time.Time        `json:"lastEvaluation"`
+	EvaluationTime float64          `json:"evaluationTime"`
+}
+
+type alert struct {
+	Labels      labels.Labels `json:"labels"`
+	Annotations labels.Labels `json:"annotations"`
+	State       string        `json:"state"`
+	ActiveAt    *time.Time    `json:"activeAt"`
+	Value       string        `json:"value"`
+}