monitoring

type AggregationMethod string

type Alert struct {
	// ID is a unique identifier for the alert
	ID string `json:"id"`

	// Name is a human-readable name for the alert
	Name string `json:"name"`

	// Description describes the alert
	Description string `json:"description"`

	// Severity indicates the severity of the alert
	Severity AlertSeverity `json:"severity"`

	// Type indicates the type of alert
	Type AlertType `json:"type"`

	// Condition defines when the alert should trigger
	Condition AlertCondition `json:"condition"`

	// Labels are additional metadata for the alert
	Labels map[string]string `json:"labels,omitempty"`

	// Annotations are additional information for the alert
	Annotations map[string]string `json:"annotations,omitempty"`

	// NotificationChannels are the channels to notify when the alert fires
	NotificationChannels []string `json:"notification_channels,omitempty"`

	// Enabled indicates whether the alert is enabled
	Enabled bool `json:"enabled"`

	// Status is the current status of the alert
	Status AlertStatus `json:"status"`
}

type AlertCondition struct {
	// MetricName is the name of the metric to check
	MetricName string `json:"metric_name"`

	// Operator is the comparison operator
	Operator AlertConditionOperator `json:"operator"`

	// Threshold is the threshold value
	Threshold float64 `json:"threshold"`

	// Duration is the duration the condition must be true for
	Duration time.Duration `json:"duration"`

	// Tags to filter metrics by
	Tags map[string]string `json:"tags,omitempty"`
}

type AlertConditionOperator string

type AlertInstance struct {
	// Alert is the alert definition
	Alert *Alert `json:"alert"`

	// Value is the value that triggered the alert
	Value float64 `json:"value"`

	// StartTime is when the alert started firing
	StartTime time.Time `json:"start_time"`

	// EndTime is when the alert stopped firing (if resolved)
	EndTime time.Time `json:"end_time,omitempty"`

	// Status is the current status of the alert instance
	Status AlertStatus `json:"status"`

	// AcknowledgedBy is who acknowledged the alert
	AcknowledgedBy string `json:"acknowledged_by,omitempty"`

	// AcknowledgedTime is when the alert was acknowledged
	AcknowledgedTime time.Time `json:"acknowledged_time,omitempty"`

	// AcknowledgementComment is a comment about the acknowledgement
	AcknowledgementComment string `json:"acknowledgement_comment,omitempty"`
}

type AlertManager struct {
	// contains filtered or unexported fields
}

type AlertSeverity string

type AlertStatus string

type AlertType string

type AnalyticsEngine struct {
	// contains filtered or unexported fields
}

type AnalyticsEngineConfig struct {
	// ProcessingInterval is how often analytics are processed
	ProcessingInterval time.Duration

	// RetentionPeriod is how long analytics results are retained
	RetentionPeriod time.Duration

	// Processors is the list of analytic processors to use
	Processors []AnalyticsProcessor

	// EnablePredictiveAnalytics enables predictive analytics
	EnablePredictiveAnalytics bool

	// PredictionWindow is how far to predict
	PredictionWindow time.Duration
}

type AnalyticsProcessor interface {
	// ID returns the processor ID
	ID() string

	// Enabled returns whether the processor is enabled
	Enabled() bool

	// RequiredMetrics returns the metric patterns required for processing
	RequiredMetrics() []string

	// RequiredPreviousResults returns the prior result IDs required for processing
	RequiredPreviousResults() []string

	// Process processes metrics and generates an analytics result
	Process(ctx context.Context, inputs *AnalyticsProcessorInputs) (*AnalyticsResult, error)
}

type AnalyticsProcessorInputs struct {
	// MetricData is a map of metric patterns to metric series
	MetricData map[string][]*MetricSeries

	// PriorResults is a map of result IDs to prior results
	PriorResults map[string]*AnalyticsResult

	// TimeRange is the time range to process
	TimeRange TimeRange

	// Parameters contains additional parameters for processing
	Parameters map[string]interface{}
}

type AnalyticsQuery struct {
	// Type filters by result type
	Type string `json:"type"`

	// Category filters by result category
	Category string `json:"category"`

	// Start time of the query range
	Start time.Time `json:"start"`

	// End time of the query range
	End time.Time `json:"end"`

	// Tags to filter by
	Tags map[string]string `json:"tags"`
}

type AnalyticsResult struct {
	// ID is the result ID
	ID string `json:"id"`

	// Type is the result type (e.g., "anomaly", "prediction")
	Type string `json:"type"`

	// Category is the result category (e.g., "system", "network")
	Category string `json:"category"`

	// Timestamp is when the result was generated
	Timestamp time.Time `json:"timestamp"`

	// TimeRange is the time range the result covers
	TimeRange TimeRange `json:"time_range"`

	// Tags are additional metadata for the result
	Tags map[string]string `json:"tags,omitempty"`

	// Summary is a short summary of the result
	Summary string `json:"summary"`

	// Details contains detailed information about the result
	Details map[string]interface{} `json:"details,omitempty"`

	// Confidence is the confidence level of the result (0-1)
	Confidence float64 `json:"confidence"`

	// Severity indicates the severity of the result (0-1)
	Severity float64 `json:"severity"`
}

type Anomaly struct {
	Value    float64
	Mean     float64
	StdDev   float64
	Severity string
	Message  string
}

type AnomalyDetectionProcessor struct {
	// contains filtered or unexported fields
}

type AnomalyDetector struct {
	// contains filtered or unexported fields
}

type CircularBuffer struct {
	// contains filtered or unexported fields
}

type CollectorManager struct {
	// contains filtered or unexported fields
}

type ComponentHealth struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

type ConsoleChannel struct {
	// contains filtered or unexported fields
}

type DistributedMetricCollector struct {
	// contains filtered or unexported fields
}

type DistributedMetricCollectorConfig struct {
	// CollectionInterval is how often metrics are collected
	CollectionInterval time.Duration

	// RetentionPeriod is how long metrics are retained
	RetentionPeriod time.Duration

	// StoragePath is where metrics are stored
	StoragePath string

	// Collectors is the list of metric collectors to use
	Collectors []MetricCollector

	// EnableAggregation enables cluster-wide metric aggregation
	EnableAggregation bool

	// AggregationEndpoints is the list of endpoints to send aggregated metrics
	AggregationEndpoints []string

	// NodeID is the unique identifier for this node
	NodeID string

	// ClusterID is the identifier for the cluster
	ClusterID string

	// Tags are additional metadata tags for metrics
	Tags map[string]string
}

type EmailChannel struct {
	// contains filtered or unexported fields
}

type ErrorRateTracker struct {
	// contains filtered or unexported fields
}

type KVMVMManager struct {
	// contains filtered or unexported fields
}

type KVMVMManagerConfig struct {
	// URI is the libvirt connection URI (e.g., qemu:///system)
	URI string
	// RefreshInterval is how often to refresh the VM cache
	RefreshInterval time.Duration
	// MetricCacheTTL is how long to cache metrics before re-collecting
	MetricCacheTTL time.Duration
	// Timeout for libvirt operations
	Timeout time.Duration
	// Detailed metrics collection (may increase overhead)
	DetailedMetrics bool
}

type LatencyMetrics struct {
	P50 float64 `json:"p50_ms"`
	P95 float64 `json:"p95_ms"`
	P99 float64 `json:"p99_ms"`
	Avg float64 `json:"avg_ms"`
	Max float64 `json:"max_ms"`
}

type LibvirtConnection interface {
	// GetDomains returns a list of all domains (VMs)
	GetDomains(ctx context.Context) ([]LibvirtDomain, error)
	// GetDomainByID returns a domain by ID
	GetDomainByID(ctx context.Context, id string) (LibvirtDomain, error)
	// Close closes the connection
	Close() error
}

type LibvirtConnectionImpl struct {
}

type LibvirtDomain interface {
	// GetID returns the domain ID
	GetID() string
	// GetName returns the domain name
	GetName() string
	// GetState returns the domain state
	GetState() (vm.VMState, error)
	// GetCPUStats returns CPU statistics
	GetCPUStats(ctx context.Context) (*VMCPUStats, error)
	// GetMemoryStats returns memory statistics
	GetMemoryStats(ctx context.Context) (*VMMemoryStats, error)
	// GetDiskStats returns disk statistics
	GetDiskStats(ctx context.Context) (map[string]*VMDiskStats, error)
	// GetNetworkStats returns network statistics
	GetNetworkStats(ctx context.Context) (map[string]*VMNetworkStats, error)
}

type LibvirtDomainImpl struct {
	// contains filtered or unexported fields
}

type Metric struct {
	// Name of the metric
	Name string `json:"name"`

	// Type of metric
	Type MetricType `json:"type"`

	// Value of the metric
	Value float64 `json:"value"`

	// Timestamp of the metric
	Timestamp time.Time `json:"timestamp"`

	// Tags associated with the metric
	Tags map[string]string `json:"tags"`

	// Unit of the metric (e.g., bytes, seconds, count)
	Unit string `json:"unit,omitempty"`

	// Source of the metric (e.g., node ID, component name)
	Source string `json:"source,omitempty"`
}

type MetricAggregationConfig struct {
	// MetricName is the name of the metric to aggregate
	MetricName string

	// Method is the aggregation method
	Method AggregationMethod

	// TagsToAggregate are tags to group by for aggregation
	TagsToAggregate []string

	// RemoveTags are tags to remove before forwarding
	RemoveTags []string

	// AddTags are additional tags to add
	AddTags map[string]string

	// Interval is how often to aggregate and forward
	Interval time.Duration
}

type MetricAggregator struct {
	// contains filtered or unexported fields
}

type MetricBatch struct {
	Metrics   []*Metric `json:"metrics"`
	Timestamp time.Time `json:"timestamp"`
	Source    string    `json:"source"`
}

type MetricCollector interface {
	// ID returns the ID of the collector
	ID() string

	// Collect collects metrics
	Collect(ctx context.Context) ([]*Metric, error)

	// Enabled returns whether the collector is enabled
	Enabled() bool
}

type MetricHistoryManager struct {
	// contains filtered or unexported fields
}

type MetricQuery struct {
	// Pattern is the name pattern to match (supports wildcards)
	Pattern string `json:"pattern"`

	// Tags to filter by
	Tags map[string]string `json:"tags"`

	// Start time of the query range
	Start time.Time `json:"start"`

	// End time of the query range
	End time.Time `json:"end"`

	// Aggregation function to apply
	Aggregation string `json:"aggregation,omitempty"`

	// GroupBy defines how to group metrics
	GroupBy []string `json:"group_by,omitempty"`
}

type MetricRegistry struct {
	// contains filtered or unexported fields
}

type MetricSeries struct {
	// Name of the metric series
	Name string `json:"name"`

	// Tags associated with the metric series
	Tags map[string]string `json:"tags"`

	// Metrics in the series
	Metrics []*Metric `json:"metrics"`
}

type MetricType string

type MetricValue struct {
	Value     float64
	Timestamp time.Time
	Tags      map[string]string
}

type MetricsCollector struct {
	// contains filtered or unexported fields
}

type MetricsConfig struct {
	CollectionInterval     time.Duration
	RetentionPeriod        time.Duration
	AnomalyThresholdStd    float64
	SLALatencyTarget       time.Duration
	SLAThroughputTarget    float64
	SLAErrorRateTarget     float64
	EnableDistributedTrace bool
	EnableProfiling        bool
	PrometheusPort         int
	PushgatewayURL         string
}

type MetricsSummary struct {
	Latency    LatencyMetrics    `json:"latency"`
	Throughput ThroughputMetrics `json:"throughput"`
	ErrorRate  float64           `json:"error_rate"`
	Timestamp  time.Time         `json:"timestamp"`
}

type MockVMManager struct {
	// contains filtered or unexported fields
}

type MonitoringConfig struct {
	// Service identification
	ServiceName string `json:"service_name"`
	Environment string `json:"environment"`
	Version     string `json:"version"`

	// Component configurations
	Dashboard  *dashboard.EngineConfig      `json:"dashboard"`
	Prometheus *prometheus.PrometheusConfig `json:"prometheus"`
	Tracing    *tracing.TracingConfig       `json:"tracing"`
	Anomaly    *ml_anomaly.DetectorConfig   `json:"anomaly"`

	// Integration settings
	EnableDashboards       bool `json:"enable_dashboards"`
	EnablePrometheus       bool `json:"enable_prometheus"`
	EnableTracing          bool `json:"enable_tracing"`
	EnableAnomalyDetection bool `json:"enable_anomaly_detection"`

	// Data retention
	MetricRetention  time.Duration `json:"metric_retention"`
	TraceRetention   time.Duration `json:"trace_retention"`
	AnomalyRetention time.Duration `json:"anomaly_retention"`

	// Performance settings
	MetricBufferSize    int           `json:"metric_buffer_size"`
	BatchProcessingSize int           `json:"batch_processing_size"`
	ProcessingInterval  time.Duration `json:"processing_interval"`

	// Security
	EnableAuthentication bool              `json:"enable_authentication"`
	TLSConfig            *TLSConfiguration `json:"tls_config"`
}

type NetworkCollector struct {
	// contains filtered or unexported fields
}

type Notification struct {
	// Type is the notification type
	Type NotificationType `json:"type"`

	// Title is the notification title
	Title string `json:"title"`

	// Message is the notification message
	Message string `json:"message"`

	// Severity is the notification severity
	Severity string `json:"severity,omitempty"`

	// Timestamp is when the notification was created
	Timestamp time.Time `json:"timestamp"`

	// Details contains additional information
	Details map[string]interface{} `json:"details,omitempty"`
}

type NotificationChannel interface {
	// ID returns the channel ID
	ID() string

	// Send sends a notification
	Send(notification *Notification) error

	// IsEnabled returns whether the channel is enabled
	IsEnabled() bool

	// Type returns the channel type
	Type() string
}

type NotificationManager struct {
	// contains filtered or unexported fields
}

type NotificationType string

type NovaCronMonitoringSystem struct {
	// contains filtered or unexported fields
}

type PredictiveAnalyticsProcessor struct {
	// contains filtered or unexported fields
}

type ProductionMetrics struct {
	// contains filtered or unexported fields
}

type SimpleAlertManager struct{}

type StorageCollector struct {
	// contains filtered or unexported fields
}

type SystemCollector struct {
	// contains filtered or unexported fields
}

type SystemHealth struct {
	Timestamp  time.Time                  `json:"timestamp"`
	Status     string                     `json:"status"` // "healthy", "degraded", "unhealthy"
	Components map[string]ComponentHealth `json:"components"`
}

type SystemMetrics struct {
	Timestamp         time.Time `json:"timestamp"`
	DashboardCount    int       `json:"dashboard_count"`
	ActiveUsers       int       `json:"active_users"`
	AnomaliesDetected int       `json:"anomalies_detected"`
	TracesCollected   int64     `json:"traces_collected"`
	MetricsIngested   int64     `json:"metrics_ingested"`
}

type SystemUtilizationProcessor struct {
	// contains filtered or unexported fields
}

type TLSConfiguration struct {
	CertFile string `json:"cert_file"`
	KeyFile  string `json:"key_file"`
	CAFile   string `json:"ca_file"`
}

type ThroughputMetrics struct {
	Current float64 `json:"current_gbps"`
	Average float64 `json:"average_gbps"`
	Max     float64 `json:"max_gbps"`
}

type TimeRange struct {
	Start time.Time
	End   time.Time
}

type UnifiedMonitoringSystem struct {
	// contains filtered or unexported fields
}

type VMCPUStats struct {
	// Usage percentage (0-100)
	Usage float64

	// Usage per core if available
	CoreUsage []float64

	// Number of vCPUs
	NumCPUs int

	// Time spent in steal (hypervisor overhead)
	StealTime float64

	// Ready time (time VM was ready but couldn't get CPU time)
	ReadyTime float64

	// System time percentage
	SystemTime float64

	// User time percentage
	UserTime float64

	// IO wait time percentage
	IOWaitTime float64
}

type VMDiskStats struct {
	// Disk identifier
	DiskID string

	// Path or name
	Path string

	// Total size in bytes
	Size int64

	// Used space in bytes
	Used int64

	// Used percentage (0-100)
	UsagePercent float64

	// Read operations per second
	ReadIOPS float64

	// Write operations per second
	WriteIOPS float64

	// Read throughput in bytes per second
	ReadThroughput float64

	// Write throughput in bytes per second
	WriteThroughput float64

	// Average read latency in milliseconds
	ReadLatency float64

	// Average write latency in milliseconds
	WriteLatency float64

	// Disk type (e.g., system, data)
	Type string
}

type VMManagerInterface interface {
	// GetVMs returns a list of all VM IDs
	GetVMs(ctx context.Context) ([]string, error)

	// GetVMStats retrieves stats for a specific VM
	GetVMStats(ctx context.Context, vmID string, detailLevel VMMetricDetailLevel) (*VMStats, error)
}

type VMMemoryStats struct {
	// Total memory allocated to the VM in bytes
	Total int64

	// Used memory in bytes
	Used int64

	// Used percentage (0-100)
	UsagePercent float64

	// Free memory in bytes
	Free int64

	// Swap usage in bytes
	SwapUsed int64

	// Swap total in bytes
	SwapTotal int64

	// Page faults per second
	PageFaults float64

	// Major page faults per second
	MajorPageFaults float64

	// Ballooning target if using dynamic memory
	BalloonTarget int64

	// Current balloon size if using dynamic memory
	BalloonCurrent int64
}

type VMMetricDetailLevel int

type VMMetricTypes struct {
	CPU              bool
	Memory           bool
	Disk             bool
	Network          bool
	IOPs             bool
	ProcessStats     bool
	ApplicationStats bool
	GuestMetrics     bool
}

type VMNetworkStats struct {
	// Interface identifier
	InterfaceID string

	// Interface name
	Name string

	// Bytes received per second
	RxBytes float64

	// Bytes transmitted per second
	TxBytes float64

	// Packets received per second
	RxPackets float64

	// Packets transmitted per second
	TxPackets float64

	// Dropped packets received
	RxDropped float64

	// Dropped packets transmitted
	TxDropped float64

	// Error packets received
	RxErrors float64

	// Error packets transmitted
	TxErrors float64
}

type VMProcessStats struct {
	// Process ID
	PID int64

	// Process name
	Name string

	// Process command line
	Command string

	// CPU usage percentage
	CPUUsage float64

	// Memory usage percentage
	MemoryPercent float64

	// Memory usage in bytes
	MemoryUsage int64

	// Read operations per second
	ReadIOPS float64

	// Write operations per second
	WriteIOPS float64

	// Read throughput in bytes per second
	ReadThroughput float64

	// Write throughput in bytes per second
	WriteThroughput float64

	// Open file descriptors
	OpenFiles int64

	// Running time in seconds
	RunTime float64
}

type VMState int

type VMStats struct {
	// VMID is the unique identifier for the VM
	VMID string

	// CPU statistics
	CPU VMCPUStats

	// Memory statistics
	Memory VMMemoryStats

	// Disk statistics
	Disks []VMDiskStats

	// Network statistics
	Networks []VMNetworkStats

	// Process statistics if available
	Processes []VMProcessStats

	// Timestamp when the stats were collected
	Timestamp time.Time
}

type VMTelemetryCollector struct {
	// contains filtered or unexported fields
}

type VMTelemetryCollectorConfig struct {
	// CollectionInterval is how often metrics are collected
	CollectionInterval time.Duration

	// VMManager is used to access VM-specific APIs
	VMManager VMManagerInterface

	// EnabledMetrics configures which metrics to collect
	EnabledMetrics VMMetricTypes

	// Tags are default tags to apply to all metrics
	Tags map[string]string

	// NodeID is the unique identifier for this node
	NodeID string

	// DetailLevel controls the granularity of metrics
	DetailLevel VMMetricDetailLevel
}

type VirtualMachineCollector struct {
	// contains filtered or unexported fields
}

type WebhookChannel struct {
	// contains filtered or unexported fields
}