Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

8.2 KB
Raw Blame
// Package ai provides AI-powered infrastructure monitoring and investigation.
package ai

import (
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/config"
)

func findingsToRecords(findings map[string]*Finding) map[string]*config.AIFindingRecord {
	// Convert from Finding to AIFindingRecord
	records := make(map[string]*config.AIFindingRecord, len(findings))
	for id, f := range findings {
		if isDemoFindingID(id) {
			// Demo findings regenerate from mock state on every demo patrol
			// cycle; persisting them would leak fixtures into a real
			// install's ai_findings.json when mock mode is later disabled.
			continue
		}
		lifecycle := make([]struct {
			At       time.Time         `json:"at"`
			Type     string            `json:"type"`
			Message  string            `json:"message,omitempty"`
			From     string            `json:"from,omitempty"`
			To       string            `json:"to,omitempty"`
			Metadata map[string]string `json:"metadata,omitempty"`
		}, 0, len(f.Lifecycle))
		for _, e := range f.Lifecycle {
			lifecycle = append(lifecycle, struct {
				At       time.Time         `json:"at"`
				Type     string            `json:"type"`
				Message  string            `json:"message,omitempty"`
				From     string            `json:"from,omitempty"`
				To       string            `json:"to,omitempty"`
				Metadata map[string]string `json:"metadata,omitempty"`
			}{
				At:       e.At,
				Type:     e.Type,
				Message:  e.Message,
				From:     e.From,
				To:       e.To,
				Metadata: e.Metadata,
			})
		}
		records[id] = &config.AIFindingRecord{
			ID:                  f.ID,
			Key:                 f.Key,
			Severity:            string(f.Severity),
			Category:            string(f.Category),
			ResourceID:          f.ResourceID,
			ResourceName:        f.ResourceName,
			ResourceType:        f.ResourceType,
			ResourceCriticality: f.ResourceCriticality,
			Node:                f.Node,
			Title:               f.Title,
			Description:         f.Description,
			Recommendation:      f.Recommendation,
			Evidence:            f.Evidence,
			FailureCause:        f.FailureCause,
			Source:              f.Source,
			DetectedAt:          f.DetectedAt,
			LastSeenAt:          f.LastSeenAt,
			ResolvedAt:          f.ResolvedAt,
			AutoResolved:        f.AutoResolved,
			ResolveReason:       f.ResolveReason,
			AcknowledgedAt:      f.AcknowledgedAt,
			SnoozedUntil:        f.SnoozedUntil,
			AlertIdentifier:     f.AlertIdentifier,
			DismissedReason:     f.DismissedReason,
			UserNote:            f.UserNote,
			TimesRaised:         f.TimesRaised,
			Suppressed:          f.Suppressed,
			RemindAt:            f.RemindAt,
			RemindCount:         f.RemindCount,
			// Investigation fields
			InvestigationSessionID: f.InvestigationSessionID,
			InvestigationStatus:    f.InvestigationStatus,
			InvestigationOutcome:   f.InvestigationOutcome,
			LastInvestigatedAt:     f.LastInvestigatedAt,
			InvestigationAttempts:  f.InvestigationAttempts,
			InvestigationRecord:    f.InvestigationRecord,
			LoopState:              f.LoopState,
			Lifecycle:              lifecycle,
			RegressionCount:        f.RegressionCount,
			LastRegressionAt:       f.LastRegressionAt,
		}
	}
	return records
}

func recordsToFindings(records map[string]*config.AIFindingRecord) map[string]*Finding {
	// Convert from AIFindingRecord to Finding
	findings := make(map[string]*Finding, len(records))
	for id, r := range records {
		lifecycle := make([]FindingLifecycleEvent, 0, len(r.Lifecycle))
		for _, e := range r.Lifecycle {
			lifecycle = append(lifecycle, FindingLifecycleEvent{
				At:       e.At,
				Type:     e.Type,
				Message:  e.Message,
				From:     e.From,
				To:       e.To,
				Metadata: e.Metadata,
			})
		}
		findings[id] = &Finding{
			ID:                  r.ID,
			Key:                 r.Key,
			Severity:            FindingSeverity(r.Severity),
			Category:            FindingCategory(r.Category),
			ResourceID:          r.ResourceID,
			ResourceName:        r.ResourceName,
			ResourceType:        r.ResourceType,
			ResourceCriticality: r.ResourceCriticality,
			Node:                r.Node,
			Title:               r.Title,
			Description:         r.Description,
			Recommendation:      r.Recommendation,
			Evidence:            r.Evidence,
			FailureCause:        r.FailureCause,
			Source:              r.Source,
			DetectedAt:          r.DetectedAt,
			LastSeenAt:          r.LastSeenAt,
			ResolvedAt:          r.ResolvedAt,
			AutoResolved:        r.AutoResolved,
			ResolveReason:       r.ResolveReason,
			AcknowledgedAt:      r.AcknowledgedAt,
			SnoozedUntil:        r.SnoozedUntil,
			AlertIdentifier:     r.AlertIdentifier,
			DismissedReason:     r.DismissedReason,
			UserNote:            r.UserNote,
			TimesRaised:         r.TimesRaised,
			Suppressed:          r.Suppressed,
			RemindAt:            r.RemindAt,
			RemindCount:         r.RemindCount,
			// Investigation fields
			InvestigationSessionID: r.InvestigationSessionID,
			InvestigationStatus:    r.InvestigationStatus,
			InvestigationOutcome:   r.InvestigationOutcome,
			LastInvestigatedAt:     r.LastInvestigatedAt,
			InvestigationAttempts:  r.InvestigationAttempts,
			InvestigationRecord:    r.InvestigationRecord,
			LoopState:              r.LoopState,
			Lifecycle:              lifecycle,
			RegressionCount:        r.RegressionCount,
			LastRegressionAt:       r.LastRegressionAt,
		}
	}
	return findings
}

func suppressionRulesToRecords(rules map[string]*SuppressionRule) map[string]*config.AISuppressionRuleRecord {
	records := make(map[string]*config.AISuppressionRuleRecord, len(rules))
	for id, r := range rules {
		if r == nil {
			continue
		}
		records[id] = &config.AISuppressionRuleRecord{
			ID:              r.ID,
			ResourceID:      r.ResourceID,
			ResourceName:    r.ResourceName,
			Category:        string(r.Category),
			Description:     r.Description,
			DismissedReason: r.DismissedReason,
			CreatedAt:       r.CreatedAt,
			CreatedFrom:     r.CreatedFrom,
			FindingID:       r.FindingID,
		}
	}
	return records
}

func recordsToSuppressionRules(records map[string]*config.AISuppressionRuleRecord) map[string]*SuppressionRule {
	rules := make(map[string]*SuppressionRule, len(records))
	for id, r := range records {
		if r == nil {
			continue
		}
		rules[id] = &SuppressionRule{
			ID:              r.ID,
			ResourceID:      r.ResourceID,
			ResourceName:    r.ResourceName,
			Category:        FindingCategory(r.Category),
			Description:     r.Description,
			DismissedReason: r.DismissedReason,
			CreatedAt:       r.CreatedAt,
			CreatedFrom:     r.CreatedFrom,
			FindingID:       r.FindingID,
		}
	}
	return rules
}

// FindingsPersistenceAdapter bridges ConfigPersistence to FindingsPersistence interface
type FindingsPersistenceAdapter struct {
	config *config.ConfigPersistence
}

// NewFindingsPersistenceAdapter creates a new adapter
func NewFindingsPersistenceAdapter(cfg *config.ConfigPersistence) *FindingsPersistenceAdapter {
	return &FindingsPersistenceAdapter{config: cfg}
}

// SaveFindings saves findings to disk via ConfigPersistence
func (a *FindingsPersistenceAdapter) SaveFindings(findings map[string]*Finding) error {
	records := findingsToRecords(findings)
	// Preserve existing suppression rules if present.
	return a.config.SaveAIFindingsWithSuppression(records, nil)
}

// LoadFindings loads findings from disk via ConfigPersistence
func (a *FindingsPersistenceAdapter) LoadFindings() (map[string]*Finding, error) {
	data, err := a.config.LoadAIFindings()
	if err != nil {
		return nil, err
	}
	return recordsToFindings(data.Findings), nil
}

// SaveFindingsAndSuppression saves findings and explicit suppression rules to disk.
func (a *FindingsPersistenceAdapter) SaveFindingsAndSuppression(findings map[string]*Finding, suppressionRules map[string]*SuppressionRule) error {
	records := findingsToRecords(findings)
	ruleRecords := suppressionRulesToRecords(suppressionRules)
	return a.config.SaveAIFindingsWithSuppression(records, ruleRecords)
}

// LoadFindingsAndSuppression loads findings and explicit suppression rules from disk.
func (a *FindingsPersistenceAdapter) LoadFindingsAndSuppression() (map[string]*Finding, map[string]*SuppressionRule, error) {
	data, err := a.config.LoadAIFindings()
	if err != nil {
		return nil, nil, err
	}
	return recordsToFindings(data.Findings), recordsToSuppressionRules(data.SuppressionRules), nil
}