SuggestedDashboards- Extend dashvalidator POC: Prometheus validator

apps/dashvalidator/pkg/validator/dashboard.go

@@ -0,0 +1,354 @@
+package validator
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+// DashboardCompatibilityRequest contains the dashboard and datasource mappings to validate
+type DashboardCompatibilityRequest struct {
+	DashboardJSON      map[string]interface{} // Dashboard JSON structure
+	DatasourceMappings []DatasourceMapping    // List of datasources to validate against
+}
+
+// DatasourceMapping maps a datasource UID to its type and optionally name/URL
+type DatasourceMapping struct {
+	UID        string       // Datasource UID
+	Type       string       // Datasource type (prometheus, mysql, etc.)
+	Name       string       // Optional: Datasource name
+	URL        string       // Datasource URL
+	HTTPClient *http.Client // Authenticated HTTP client
+}
+
+// DashboardCompatibilityResult contains the validation results for a dashboard
+type DashboardCompatibilityResult struct {
+	CompatibilityScore float64                      // Overall compatibility (0.0 - 1.0)
+	DatasourceResults  []DatasourceValidationResult // Per-datasource results
+}
+
+// DatasourceValidationResult contains validation results for one datasource
+type DatasourceValidationResult struct {
+	UID                string
+	Type               string
+	Name               string
+	TotalQueries       int
+	CheckedQueries     int
+	TotalMetrics       int
+	FoundMetrics       int
+	MissingMetrics     []string
+	QueryBreakdown     []QueryResult
+	CompatibilityScore float64
+}
+
+// ValidateDashboardCompatibility is the main entry point for validating dashboard compatibility
+// It extracts queries from the dashboard, validates them against each datasource, and returns aggregated results
+func ValidateDashboardCompatibility(ctx context.Context, req DashboardCompatibilityRequest) (*DashboardCompatibilityResult, error) {
+	result := &DashboardCompatibilityResult{
+		DatasourceResults: make([]DatasourceValidationResult, 0, len(req.DatasourceMappings)),
+	}
+
+	// Step 1: Extract queries from dashboard JSON
+	queries, err := extractQueriesFromDashboard(req.DashboardJSON)
+	if err != nil {
+		return nil, fmt.Errorf("failed to extract queries from dashboard: %w", err)
+	}
+
+	fmt.Printf("[DEBUG] Extracted %d queries from dashboard\n", len(queries))
+	for i, q := range queries {
+		fmt.Printf("[DEBUG] Query %d: DS=%s, RefID=%s, Query=%s\n", i, q.DatasourceUID, q.RefID, q.QueryText)
+	}
+
+	// Step 2: Group queries by datasource UID
+	queriesByDatasource := groupQueriesByDatasource(queries)
+
+	fmt.Printf("[DEBUG] Grouped queries by %d datasources\n", len(queriesByDatasource))
+	for dsUID, dsQueries := range queriesByDatasource {
+		fmt.Printf("[DEBUG] Datasource %s has %d queries\n", dsUID, len(dsQueries))
+	}
+
+	// Step 3: Validate each datasource
+	var totalCompatibility float64
+	validatedCount := 0
+
+	for _, dsMapping := range req.DatasourceMappings {
+		fmt.Printf("[DEBUG] Processing datasource mapping: UID=%s, Type=%s, URL=%s\n", dsMapping.UID, dsMapping.Type, dsMapping.URL)
+
+		// Get queries for this datasource
+		dsQueries, ok := queriesByDatasource[dsMapping.UID]
+		if !ok || len(dsQueries) == 0 {
+			// No queries for this datasource, skip
+			fmt.Printf("[DEBUG] No queries found for datasource %s, skipping\n", dsMapping.UID)
+			continue
+		}
+
+		fmt.Printf("[DEBUG] Found %d queries for datasource %s\n", len(dsQueries), dsMapping.UID)
+
+		// Get validator for this datasource type
+		v, err := GetValidator(dsMapping.Type)
+		if err != nil {
+			// Unsupported datasource type, skip but log
+			fmt.Printf("[DEBUG] Failed to get validator for type %s: %v\n", dsMapping.Type, err)
+			continue
+		}
+
+		fmt.Printf("[DEBUG] Got validator for type %s, starting validation\n", dsMapping.Type)
+
+		// Build Datasource struct
+		ds := Datasource{
+			UID:        dsMapping.UID,
+			Type:       dsMapping.Type,
+			Name:       dsMapping.Name,
+			URL:        dsMapping.URL,
+			HTTPClient: dsMapping.HTTPClient,
+		}
+
+		// Validate queries
+		validationResult, err := v.ValidateQueries(ctx, dsQueries, ds)
+		if err != nil {
+			// Validation failed for this datasource, skip but could log
+			continue
+		}
+
+		// Convert to DatasourceValidationResult
+		dsResult := DatasourceValidationResult{
+			UID:                dsMapping.UID,
+			Type:               dsMapping.Type,
+			Name:               dsMapping.Name,
+			TotalQueries:       validationResult.TotalQueries,
+			CheckedQueries:     validationResult.CheckedQueries,
+			TotalMetrics:       validationResult.TotalMetrics,
+			FoundMetrics:       validationResult.FoundMetrics,
+			MissingMetrics:     validationResult.MissingMetrics,
+			QueryBreakdown:     validationResult.QueryBreakdown,
+			CompatibilityScore: validationResult.CompatibilityScore,
+		}
+
+		result.DatasourceResults = append(result.DatasourceResults, dsResult)
+		totalCompatibility += validationResult.CompatibilityScore
+		validatedCount++
+	}
+
+	// Step 4: Calculate overall compatibility score
+	if validatedCount > 0 {
+		result.CompatibilityScore = totalCompatibility / float64(validatedCount)
+	} else {
+		result.CompatibilityScore = 1.0 // No datasources = perfect compatibility
+	}
+
+	return result, nil
+}
+
+// extractQueriesFromDashboard parses the dashboard JSON and extracts all queries
+// Supports both v1 (legacy) and v2 (new) dashboard formats
+func extractQueriesFromDashboard(dashboardJSON map[string]interface{}) ([]DashboardQuery, error) {
+	var queries []DashboardQuery
+
+	// Debug: Print what keys we have
+	fmt.Printf("[DEBUG] Dashboard JSON keys: ")
+	for key := range dashboardJSON {
+		fmt.Printf("%s, ", key)
+	}
+	fmt.Printf("\n")
+
+	// Detect dashboard version (v1 uses "panels", v2 uses different structure)
+	// For MVP, we only support v1 (legacy format with panels array)
+	if !isV1Dashboard(dashboardJSON) {
+		fmt.Printf("[DEBUG] isV1Dashboard returned false, 'panels' key exists: %v\n", dashboardJSON["panels"] != nil)
+		return nil, fmt.Errorf("unsupported dashboard format: only v1 dashboards are supported in MVP")
+	}
+
+	// Extract panels array
+	panels, ok := dashboardJSON["panels"].([]interface{})
+	if !ok {
+		// No panels in dashboard, return empty array
+		return queries, nil
+	}
+
+	// Iterate through all panels
+	for _, panelInterface := range panels {
+		panel, ok := panelInterface.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		// Extract queries from this panel
+		panelQueries := extractQueriesFromPanel(panel)
+		queries = append(queries, panelQueries...)
+
+		// Handle nested panels in collapsed rows
+		nestedPanels, hasNested := panel["panels"].([]interface{})
+		if hasNested {
+			for _, nestedPanelInterface := range nestedPanels {
+				nestedPanel, ok := nestedPanelInterface.(map[string]interface{})
+				if !ok {
+					continue
+				}
+				nestedQueries := extractQueriesFromPanel(nestedPanel)
+				queries = append(queries, nestedQueries...)
+			}
+		}
+	}
+
+	return queries, nil
+}
+
+// isV1Dashboard checks if a dashboard is in v1 (legacy) format
+// v1 dashboards have a "panels" array at the top level
+func isV1Dashboard(dashboard map[string]interface{}) bool {
+	_, hasPanels := dashboard["panels"]
+	return hasPanels
+}
+
+// extractQueriesFromPanel extracts all queries/targets from a single panel
+func extractQueriesFromPanel(panel map[string]interface{}) []DashboardQuery {
+	var queries []DashboardQuery
+
+	// Get panel info for context
+	panelTitle := getStringValue(panel, "title", "Untitled Panel")
+	panelID := getIntValue(panel, "id", 0)
+
+	// Extract targets array (queries)
+	targets, hasTargets := panel["targets"].([]interface{})
+	if !hasTargets {
+		return queries
+	}
+
+	// Iterate through each target/query
+	for _, targetInterface := range targets {
+		target, ok := targetInterface.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		// Extract datasource UID
+		datasourceUID := extractDatasourceUID(target, panel)
+		if datasourceUID == "" {
+			// Skip queries without datasource
+			continue
+		}
+
+		// Extract query text (different fields for different datasources)
+		queryText := extractQueryText(target)
+		if queryText == "" {
+			// Skip empty queries
+			continue
+		}
+
+		// Extract refId (A, B, C, etc.)
+		refID := getStringValue(target, "refId", "")
+
+		// Build DashboardQuery
+		query := DashboardQuery{
+			DatasourceUID: datasourceUID,
+			RefID:         refID,
+			QueryText:     queryText,
+			PanelTitle:    panelTitle,
+			PanelID:       panelID,
+		}
+
+		queries = append(queries, query)
+	}
+
+	return queries
+}
+
+// extractDatasourceUID gets the datasource UID from a target, falling back to panel datasource
+func extractDatasourceUID(target map[string]interface{}, panel map[string]interface{}) string {
+	// Try target-level datasource first
+	if ds, ok := target["datasource"]; ok {
+		if uid := getDatasourceUIDFromValue(ds); uid != "" {
+			return uid
+		}
+	}
+
+	// Fall back to panel-level datasource
+	if ds, ok := panel["datasource"]; ok {
+		if uid := getDatasourceUIDFromValue(ds); uid != "" {
+			return uid
+		}
+	}
+
+	return ""
+}
+
+// getDatasourceUIDFromValue extracts UID from datasource value (can be string or object)
+func getDatasourceUIDFromValue(ds interface{}) string {
+	switch v := ds.(type) {
+	case string:
+		// Direct UID string
+		return v
+	case map[string]interface{}:
+		// Structured datasource reference { uid: "...", type: "..." }
+		return getStringValue(v, "uid", "")
+	default:
+		return ""
+	}
+}
+
+// extractQueryText extracts the query text from a target
+// Different datasources use different field names (expr, query, rawSql, etc.)
+func extractQueryText(target map[string]interface{}) string {
+	// Try common query field names
+	queryFields := []string{"expr", "query", "rawSql", "rawQuery", "target", "measurement"}
+
+	for _, field := range queryFields {
+		if queryText := getStringValue(target, field, ""); queryText != "" {
+			return queryText
+		}
+	}
+
+	return ""
+}
+
+// getStringValue safely extracts a string value from a map
+func getStringValue(m map[string]interface{}, key string, defaultValue string) string {
+	if value, ok := m[key]; ok {
+		if s, ok := value.(string); ok {
+			return s
+		}
+	}
+	return defaultValue
+}
+
+// getIntValue safely extracts an int value from a map
+func getIntValue(m map[string]interface{}, key string, defaultValue int) int {
+	if value, ok := m[key]; ok {
+		switch v := value.(type) {
+		case int:
+			return v
+		case float64:
+			return int(v)
+		case int64:
+			return int(v)
+		}
+	}
+	return defaultValue
+}
+
+// DashboardQuery represents a query extracted from a dashboard panel
+type DashboardQuery struct {
+	DatasourceUID string // Which datasource this query belongs to
+	RefID         string // Query reference ID
+	QueryText     string // The actual query
+	PanelTitle    string // Panel title
+	PanelID       int    // Panel ID
+}
+
+// groupQueriesByDatasource groups dashboard queries by their datasource UID
+func groupQueriesByDatasource(queries []DashboardQuery) map[string][]Query {
+	grouped := make(map[string][]Query)
+
+	for _, dq := range queries {
+		q := Query{
+			RefID:      dq.RefID,
+			QueryText:  dq.QueryText,
+			PanelTitle: dq.PanelTitle,
+			PanelID:    dq.PanelID,
+		}
+
+		grouped[dq.DatasourceUID] = append(grouped[dq.DatasourceUID], q)
+	}
+
+	return grouped
+}

apps/dashvalidator/pkg/validator/prometheus/fetcher.go

@@ -0,0 +1,76 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// Fetcher fetches available metrics from a Prometheus datasource
+type Fetcher struct{}
+
+// NewFetcher creates a new Prometheus metrics fetcher
+func NewFetcher() *Fetcher {
+	return &Fetcher{}
+}
+
+// prometheusResponse represents the Prometheus API response structure
+type prometheusResponse struct {
+	Status string   `json:"status"`
+	Data   []string `json:"data"`
+	Error  string   `json:"error,omitempty"`
+}
+
+// FetchMetrics queries Prometheus to get all available metric names
+// It uses the /api/v1/label/__name__/values endpoint
+// The provided HTTP client should have proper authentication configured
+func (f *Fetcher) FetchMetrics(ctx context.Context, datasourceURL string, client *http.Client) ([]string, error) {
+	// Build the API URL
+	baseURL, err := url.Parse(datasourceURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid datasource URL: %w", err)
+	}
+
+	// Prometheus metrics endpoint
+	apiPath, err := url.Parse("/api/v1/label/__name__/values")
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse API path: %w", err)
+	}
+
+	fullURL := baseURL.ResolveReference(apiPath)
+
+	// Create the request
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fullURL.String(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Execute the request using the provided authenticated client
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch metrics from Prometheus: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Check status code
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("Prometheus API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Parse the response
+	var promResp prometheusResponse
+	if err := json.NewDecoder(resp.Body).Decode(&promResp); err != nil {
+		return nil, fmt.Errorf("failed to decode Prometheus response: %w", err)
+	}
+
+	// Check Prometheus API status
+	if promResp.Status != "success" {
+		return nil, fmt.Errorf("Prometheus API returned error: %s", promResp.Error)
+	}
+
+	return promResp.Data, nil
+}

apps/dashvalidator/pkg/validator/prometheus/parser.go

@@ -0,0 +1,49 @@
+package prometheus
+
+import (
+	"fmt"
+
+	"github.com/prometheus/prometheus/promql/parser"
+)
+
+// Parser extracts metric names from PromQL queries
+type Parser struct{}
+
+// NewParser creates a new PromQL parser
+func NewParser() *Parser {
+	return &Parser{}
+}
+
+// ExtractMetrics parses a PromQL query and extracts all metric names
+// For example: "rate(http_requests_total[5m])" returns ["http_requests_total"]
+func (p *Parser) ExtractMetrics(query string) ([]string, error) {
+	// Parse the PromQL expression
+	expr, err := parser.ParseExpr(query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse PromQL query: %w", err)
+	}
+
+	// Extract metric names by walking the AST
+	metrics := make(map[string]bool) // Use map to deduplicate
+	parser.Inspect(expr, func(node parser.Node, _ []parser.Node) error {
+		// VectorSelector represents a metric selector like "up" or "up{job="foo"}"
+		if vs, ok := node.(*parser.VectorSelector); ok {
+			metrics[vs.Name] = true
+		}
+		// MatrixSelector represents range queries like "up[5m]"
+		if ms, ok := node.(*parser.MatrixSelector); ok {
+			if vs, ok := ms.VectorSelector.(*parser.VectorSelector); ok {
+				metrics[vs.Name] = true
+			}
+		}
+		return nil
+	})
+
+	// Convert map to slice
+	result := make([]string, 0, len(metrics))
+	for metric := range metrics {
+		result = append(result, metric)
+	}
+
+	return result, nil
+}

apps/dashvalidator/pkg/validator/prometheus/validator.go

@@ -0,0 +1,149 @@
+package prometheus
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/grafana/grafana/apps/dashvalidator/pkg/validator"
+)
+
+// Register Prometheus validator on package import
+func init() {
+	validator.RegisterValidator("prometheus", func() validator.DatasourceValidator {
+		return NewValidator()
+	})
+}
+
+// Validator implements validator.DatasourceValidator for Prometheus datasources
+type Validator struct {
+	parser  *Parser
+	fetcher *Fetcher
+}
+
+// NewValidator creates a new Prometheus validator
+func NewValidator() validator.DatasourceValidator {
+	return &Validator{
+		parser:  NewParser(),
+		fetcher: NewFetcher(),
+	}
+}
+
+// ValidateQueries validates Prometheus queries against the datasource
+func (v *Validator) ValidateQueries(ctx context.Context, queries []validator.Query, datasource validator.Datasource) (*validator.ValidationResult, error) {
+	fmt.Printf("[DEBUG PROM] Starting validation for %d queries against datasource %s\n", len(queries), datasource.URL)
+
+	result := &validator.ValidationResult{
+		TotalQueries:   len(queries),
+		QueryBreakdown: make([]validator.QueryResult, 0, len(queries)),
+	}
+
+	// Step 1: Parse all queries to extract metrics
+	allMetrics := make(map[string]bool) // Use map to deduplicate
+	queryMetrics := make(map[int][]string)
+
+	for i, query := range queries {
+		fmt.Printf("[DEBUG PROM] Parsing query %d: %s\n", i, query.QueryText)
+		metrics, err := v.parser.ExtractMetrics(query.QueryText)
+		if err != nil {
+			// If we can't parse the query, we still continue with others
+			// but we don't count this query as "checked"
+			fmt.Printf("[DEBUG PROM] Failed to parse query %d: %v\n", i, err)
+			continue
+		}
+		fmt.Printf("[DEBUG PROM] Extracted %d metrics from query %d: %v\n", len(metrics), i, metrics)
+		result.CheckedQueries++
+		queryMetrics[i] = metrics
+
+		// Add to global metrics set
+		for _, metric := range metrics {
+			allMetrics[metric] = true
+		}
+	}
+
+	// Convert map to slice for fetcher
+	metricsToCheck := make([]string, 0, len(allMetrics))
+	for metric := range allMetrics {
+		metricsToCheck = append(metricsToCheck, metric)
+	}
+	result.TotalMetrics = len(metricsToCheck)
+
+	fmt.Printf("[DEBUG PROM] Total metrics to check: %d - %v\n", len(metricsToCheck), metricsToCheck)
+
+	// Step 2: Fetch available metrics from Prometheus
+	fmt.Printf("[DEBUG PROM] Fetching available metrics from %s\n", datasource.URL)
+	availableMetrics, err := v.fetcher.FetchMetrics(ctx, datasource.URL, datasource.HTTPClient)
+	if err != nil {
+		fmt.Printf("[DEBUG PROM] Failed to fetch metrics: %v\n", err)
+		return nil, fmt.Errorf("failed to fetch metrics from Prometheus: %w", err)
+	}
+	fmt.Printf("[DEBUG PROM] Fetched %d available metrics from Prometheus\n", len(availableMetrics))
+
+	// Build a set for O(1) lookup
+	availableSet := make(map[string]bool)
+	for _, metric := range availableMetrics {
+		availableSet[metric] = true
+	}
+
+	// Step 3: Calculate compatibility
+	missingMetricsMap := make(map[string]bool)
+	for _, metric := range metricsToCheck {
+		if !availableSet[metric] {
+			missingMetricsMap[metric] = true
+		}
+	}
+	result.FoundMetrics = result.TotalMetrics - len(missingMetricsMap)
+
+	// Convert missing metrics map to slice
+	result.MissingMetrics = make([]string, 0, len(missingMetricsMap))
+	for metric := range missingMetricsMap {
+		result.MissingMetrics = append(result.MissingMetrics, metric)
+	}
+
+	// Step 4: Build per-query breakdown
+	for i, query := range queries {
+		metrics, ok := queryMetrics[i]
+		if !ok {
+			// Query wasn't parsed successfully, skip
+			continue
+		}
+
+		queryResult := validator.QueryResult{
+			PanelTitle:   query.PanelTitle,
+			PanelID:      query.PanelID,
+			QueryRefID:   query.RefID,
+			TotalMetrics: len(metrics),
+		}
+
+		// Check which metrics from this query are missing
+		queryMissing := make([]string, 0)
+		for _, metric := range metrics {
+			if missingMetricsMap[metric] {
+				queryMissing = append(queryMissing, metric)
+			}
+		}
+
+		queryResult.MissingMetrics = queryMissing
+		queryResult.FoundMetrics = queryResult.TotalMetrics - len(queryMissing)
+
+		// Calculate query-level compatibility score
+		if queryResult.TotalMetrics > 0 {
+			queryResult.CompatibilityScore = float64(queryResult.FoundMetrics) / float64(queryResult.TotalMetrics)
+		} else {
+			queryResult.CompatibilityScore = 1.0 // No metrics = perfect compatibility
+		}
+
+		result.QueryBreakdown = append(result.QueryBreakdown, queryResult)
+	}
+
+	// Step 5: Calculate overall compatibility score
+	if result.TotalMetrics > 0 {
+		result.CompatibilityScore = float64(result.FoundMetrics) / float64(result.TotalMetrics)
+	} else {
+		result.CompatibilityScore = 1.0 // No metrics = perfect compatibility
+	}
+
+	fmt.Printf("[DEBUG PROM] Validation complete! Score: %.2f, Found: %d/%d metrics\n",
+		result.CompatibilityScore, result.FoundMetrics, result.TotalMetrics)
+
+	return result, nil
+}

apps/dashvalidator/pkg/validator/types.go

@@ -0,0 +1,74 @@
+package validator
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+// DatasourceValidator validates dashboard queries against a datasource
+// Implementations exist per datasource type (Prometheus, MySQL, etc.)
+type DatasourceValidator interface {
+	// ValidateQueries checks if queries are compatible with the datasource
+	ValidateQueries(ctx context.Context, queries []Query, datasource Datasource) (*ValidationResult, error)
+}
+
+// Query represents a dashboard query to validate
+type Query struct {
+	RefID      string // Query reference ID (A, B, C, etc.)
+	QueryText  string // The actual query text (PromQL, SQL, etc.)
+	PanelTitle string // Panel title for user-friendly reporting
+	PanelID    int    // Panel ID for reference
+}
+
+// Datasource contains connection information for a datasource
+type Datasource struct {
+	UID        string       // Datasource UID from dashboard
+	Type       string       // Datasource type (prometheus, mysql, etc.)
+	Name       string       // Datasource name for reporting
+	URL        string       // Datasource URL for API calls
+	HTTPClient *http.Client // Authenticated HTTP client for making requests
+}
+
+// ValidationResult contains validation results for a datasource
+type ValidationResult struct {
+	TotalQueries       int           // Total number of queries found
+	CheckedQueries     int           // Number of queries successfully checked
+	TotalMetrics       int           // Total metrics/entities referenced
+	FoundMetrics       int           // Metrics found in datasource
+	MissingMetrics     []string      // List of missing metrics
+	QueryBreakdown     []QueryResult // Per-query results
+	CompatibilityScore float64       // Overall compatibility (0.0 - 1.0)
+}
+
+// QueryResult contains validation results for a single query
+type QueryResult struct {
+	PanelTitle         string   // Panel title
+	PanelID            int      // Panel ID
+	QueryRefID         string   // Query reference ID
+	TotalMetrics       int      // Metrics in this query
+	FoundMetrics       int      // Metrics found
+	MissingMetrics     []string // Missing metrics for this query
+	CompatibilityScore float64  // Query compatibility (0.0 - 1.0)
+}
+
+// validatorRegistry holds registered validator constructors
+// Validators register themselves using RegisterValidator in their init() functions
+var validatorRegistry = make(map[string]func() DatasourceValidator)
+
+// RegisterValidator registers a validator constructor for a datasource type
+// This is called by validator implementations in their init() functions
+// Example: validator.RegisterValidator("prometheus", func() validator.DatasourceValidator { return NewValidator() })
+func RegisterValidator(dsType string, constructor func() DatasourceValidator) {
+	validatorRegistry[dsType] = constructor
+}
+
+// GetValidator returns a validator for the given datasource type
+// Returns an error if the datasource type is not supported
+func GetValidator(dsType string) (DatasourceValidator, error) {
+	constructor, ok := validatorRegistry[dsType]
+	if !ok {
+		return nil, fmt.Errorf("unsupported datasource type: %s", dsType)
+	}
+	return constructor(), nil
+}