performance

type ActionType string

type Alert struct {
	Timestamp   time.Time
	Context     map[string]any
	ID          string
	RuleID      string
	Metric      string
	Severity    AlertSeverity
	Status      AlertStatus
	Description string
	Value       float64
	Threshold   float64
}

type AlertAction struct {
	Parameters map[string]any
	Type       ActionType
	Target     string
}

type AlertCondition string

type AlertRule struct {
	ID          string
	Name        string
	Description string
	Metric      string
	Condition   AlertCondition
	Severity    AlertSeverity
	Actions     []AlertAction
	Threshold   float64
	Duration    time.Duration
	Enabled     bool
}

type AlertSeverity string

type AlertStatus string

type AlertThresholds struct {
	ResponseTime   time.Duration
	Throughput     float64
	ErrorRate      float64
	MemoryUsage    float64
	CPUUsage       float64
	DiskUsage      float64
	NetworkLatency time.Duration
}

type AlertingSystem interface {
	RegisterAlert(alert AlertRule) error
	TriggerAlert(ctx context.Context, alert Alert) error
	GetActiveAlerts() []Alert
	AcknowledgeAlert(alertID string) error
	ResolveAlert(alertID string) error
}

type AnalysisResult struct {
	Timestamp       time.Time
	AnalysisType    AnalysisType
	Bottlenecks     []Bottleneck
	Patterns        []PerformancePattern
	Anomalies       []Anomaly
	Trends          []Trend
	Predictions     []Prediction
	Recommendations []Recommendation
	Score           PerformanceScore
}

type AnalysisType string

type Anomaly struct {
	Timestamp   time.Time
	Type        AnomalyType
	Metric      string
	Severity    AnomalySeverity
	Description string
	Causes      []string
	Expected    float64
	Actual      float64
	Deviation   float64
}

type AnomalySeverity string

type AnomalyType string

type AppliedOptimization struct {
	Parameters   map[string]any
	Type         OptimizationType
	Description  string
	RollbackInfo string
	Impact       ImpactMetrics
	Reversible   bool
}

type Benchmark interface {
	Run(ctx context.Context, config BenchmarkConfig) (BenchmarkResult, error)
	GetBaseline() BenchmarkResult
	SetBaseline(baseline BenchmarkResult) error
	Compare(current, baseline BenchmarkResult) ComparisonResult
	GenerateReport() BenchmarkReport
}

type BenchmarkConfig struct {
	// Slices first (24 bytes each)
	Scenarios []BenchmarkScenario
	Targets   []string
	// 8-byte aligned fields
	Duration         time.Duration
	RequestRate      float64
	WarmupDuration   time.Duration
	CooldownDuration time.Duration
	// 4-byte fields grouped
	Concurrency int
	PayloadSize int
}

type BenchmarkReport struct {
	Timestamp   time.Time
	Version     string
	Results     []BenchmarkResult
	Comparisons []ComparisonResult
	Trends      TrendAnalysis
	Summary     BenchmarkSummary
}

type BenchmarkResult struct {
	StartTime      time.Time
	EndTime        time.Time
	CustomMetrics  map[string]any
	ErrorStats     ErrorStats
	Config         BenchmarkConfig
	ResourceUsage  ResourceUsageStats
	ResponseTimes  ResponseTimeStats
	Percentiles    PercentileStats
	Throughput     ThroughputStats
	Duration       time.Duration
	FailedRequests int64
	SuccessfulReqs int64
	TotalRequests  int64
}

type BenchmarkScenario struct {
	Name        string
	Operations  []Operation
	Constraints []Constraint
	Weight      float64
}

type BenchmarkSummary struct {
	TotalBenchmarks int
	Improvements    int
	Regressions     int
	Unchanged       int
	OverallScore    float64
}

type Bottleneck struct {
	Type        BottleneckType
	Component   string
	Severity    BottleneckSeverity
	Impact      ImpactLevel
	Description string
	Metrics     map[string]float64
	Suggestions []string
	Priority    int
}

type BottleneckSeverity string

type BottleneckType string

type CPUMetrics struct {
	LoadAverage []float64
	Usage       float64
	Cores       int
	Frequency   float64
	Temperature float64
}

type CPUUsageStats struct {
	// 8-byte aligned fields first
	Peak    float64
	Average float64
	Minimum float64
	// 4-byte field last
	Cores int
}

type CapacityInfo struct {
	Unit        string
	Current     float64
	Maximum     float64
	Utilization float64
	Available   float64
}

type CapacityMetrics struct {
	CPU     CapacityInfo
	Memory  CapacityInfo
	Storage CapacityInfo
	Network CapacityInfo
}

type ComparisonResult struct {
	OverallChange   PerformanceChange
	Improvements    []Improvement
	Regressions     []Regression
	Recommendations []string
	Significance    StatisticalSignificance
	Baseline        BenchmarkResult
	Current         BenchmarkResult
}

type ComplexityLevel string

type Constraint struct {
	Type     ConstraintType
	Operator ConstraintOperator
	Metric   string
	Value    float64
}

type ConstraintOperator string

type ConstraintType string

type CostBreakdown struct {
	Compute float64
	Storage float64
	Network float64
	Other   float64
	Total   float64
	Period  time.Duration
}

type CostEstimate struct {
	Current   CostBreakdown
	Projected CostBreakdown
	Savings   CostBreakdown
	ROI       ROIAnalysis
}

type CostImpact struct {
	Operational    float64
	Infrastructure float64
	Development    float64
	Maintenance    float64
}

type DemandForecast struct {
	Methodology string
	Scenarios   []DemandScenario
	TimeHorizon time.Duration
	Confidence  float64
}

type DemandScenario struct {
	Name        string
	Growth      GrowthPattern
	Peak        PeakDemand
	Probability float64
}

type DiskMetrics struct {
	ReadOps    uint64
	WriteOps   uint64
	ReadBytes  uint64
	WriteBytes uint64
	Usage      float64
	IOPS       float64
	Latency    time.Duration
}

type DiskUsageStats struct {
	ReadBytes   uint64
	WriteBytes  uint64
	ReadOps     uint64
	WriteOps    uint64
	AverageIOPS float64
}

type EffortEstimate struct {
	Complexity   ComplexityLevel
	Skills       []string
	Resources    []string
	Dependencies []string
	Hours        float64
}

type ErrorStats struct {
	ErrorTypes    map[string]int64
	TotalErrors   int64
	ErrorRate     float64
	TimeoutErrors int64
	NetworkErrors int64
	ServerErrors  int64
}

type GrowthPattern struct {
	Type        GrowthType
	Seasonality []SeasonalPattern
	Rate        float64
}

type GrowthType string

type ImpactEstimate struct {
	Performance float64
	Cost        float64
	Risk        float64
	Timeline    time.Duration
	Confidence  float64
}

type ImpactLevel string

type ImpactMetrics struct {
	Performance PerformanceImpact
	Resource    ResourceImpact
	Cost        CostImpact
	Risk        RiskImpact
}

type Improvement struct {
	Metric       string
	OldValue     float64
	NewValue     float64
	Change       float64
	Percentage   float64
	Significance float64
}

type ImprovementMetrics struct {
	ResponseTimeImprovement float64
	ThroughputImprovement   float64
	ErrorRateImprovement    float64
	ResourceEfficiency      float64
	CostReduction           float64
	OverallScore            float64
}

type InsightType string

type IssueSeverity string

type IssueType string

type MemoryMetrics struct {
	GCPauses    []time.Duration
	Used        uint64
	Available   uint64
	Total       uint64
	Percentage  float64
	Allocations uint64
	Frees       uint64
}

type MemoryUsageStats struct {
	// 8-byte aligned fields first
	Peak    uint64
	Average uint64
	Minimum uint64
	GCTime  time.Duration
	// 4-byte field last
	GCCount int
}

type NetworkMetrics struct {
	BytesIn     uint64
	BytesOut    uint64
	PacketsIn   uint64
	PacketsOut  uint64
	Latency     time.Duration
	Bandwidth   float64
	Connections int
}

type NetworkUsageStats struct {
	// 8-byte aligned fields first
	BytesIn    uint64
	BytesOut   uint64
	PacketsIn  uint64
	PacketsOut uint64
	// 4-byte field last
	Connections int
}

type Operation struct {
	Headers map[string]string
	Type    OperationType
	Target  string
	Payload []byte
	Timeout time.Duration
	Retries int
}

type OperationType string

type OptimizationConstraint struct {
	Type     ConstraintType
	Operator ConstraintOperator
	Value    float64
	Priority int
}

type OptimizationLevel string

type OptimizationObjective struct {
	Metric   string
	Target   float64
	Weight   float64
	Priority int
}

type OptimizationResult struct {
	Timestamp     time.Time
	Target        OptimizationTarget
	Optimizations []AppliedOptimization
	Errors        []string
	BeforeMetrics PerformanceMetrics
	AfterMetrics  PerformanceMetrics
	Improvement   ImprovementMetrics
	Duration      time.Duration
	Success       bool
}

type OptimizationTarget struct {
	Type        TargetType
	Component   string
	Constraints []OptimizationConstraint
	Objectives  []OptimizationObjective
	Metrics     PerformanceMetrics
}

type OptimizationType string

type Optimizer interface {
	Optimize(ctx context.Context, target OptimizationTarget) (OptimizationResult, error)
	GetOptimizationType() OptimizationType
	EstimateImpact(target OptimizationTarget) ImpactEstimate
	ValidateOptimization(result OptimizationResult) ValidationResult
}

type PatternExample struct {
	Timestamp time.Time
	Context   string
	Value     float64
}

type PatternType string

type PeakDemand struct {
	Timestamp time.Time
	Value     float64
	Duration  time.Duration
	Frequency time.Duration
}

type PercentileStats struct {
	P50  time.Duration
	P75  time.Duration
	P90  time.Duration
	P95  time.Duration
	P99  time.Duration
	P999 time.Duration
}

type PerformanceAnalyzer interface {
	Analyze(ctx context.Context, metrics []PerformanceMetrics) (AnalysisResult, error)
	IdentifyBottlenecks(metrics PerformanceMetrics) []Bottleneck
	GenerateRecommendations(analysis AnalysisResult) []Recommendation
	PredictScaling(trends []PerformanceMetrics) ScalingPrediction
}

type PerformanceChange string

type PerformanceConfig struct {
	OptimizationLevel   OptimizationLevel
	AlertThresholds     AlertThresholds
	MonitoringInterval  time.Duration
	BenchmarkTimeout    time.Duration
	TrendAnalysisWindow time.Duration
	RegressionThreshold float64
	EnablePredictive    bool
	EnableAutoOptimize  bool
}

type PerformanceImpact struct {
	ResponseTime float64
	Throughput   float64
	ErrorRate    float64
	Availability float64
}

type PerformanceMetrics struct {
	Timestamp      time.Time
	CustomMetrics  map[string]float64
	CPUUsage       CPUMetrics
	MemoryUsage    MemoryMetrics
	DiskUsage      DiskMetrics
	NetworkMetrics NetworkMetrics
	ResponseTime   time.Duration
	RequestCount   int64
	ErrorCount     int64
	ActiveUsers    int64
	Throughput     float64
	ErrorRate      float64
}

type PerformanceMonitor interface {
	StartMonitoring(ctx context.Context, target string) error
	StopMonitoring() error
	GetMetrics(ctx context.Context) (PerformanceMetrics, error)
	DetectRegression(current, baseline PerformanceMetrics) bool
	GetThresholds() PerformanceThresholds
	SetThresholds(thresholds PerformanceThresholds) error
}

type PerformanceOptimizationResult struct {
	StartTime        time.Time
	EndTime          time.Time
	Monitoring       map[string]PerformanceMetrics
	Benchmarks       map[string]BenchmarkResult
	Analysis         map[string]AnalysisResult
	Optimizations    map[string]OptimizationResult
	Target           string
	Errors           []string
	PerformanceScore PerformanceScore
	Duration         time.Duration
}

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

type PerformancePattern struct {
	Type        PatternType
	Description string
	Impact      ImpactLevel
	Examples    []PatternExample
	Frequency   time.Duration
	Confidence  float64
}

type PerformanceScore struct {
	Breakdown    map[string]float64
	Overall      float64
	ResponseTime float64
	Throughput   float64
	Reliability  float64
	Efficiency   float64
	Scalability  float64
}

type PerformanceThresholds struct {
	MaxResponseTime   time.Duration
	MinThroughput     float64
	MaxErrorRate      float64
	MaxMemoryUsage    float64
	MaxCPUUsage       float64
	MaxDiskUsage      float64
	MaxNetworkLatency time.Duration
}

type Prediction struct {
	Type        PredictionType
	Metric      string
	Scenario    PredictionScenario
	Assumptions []string
	TimeHorizon time.Duration
	Value       float64
	Confidence  float64
}

type PredictionScenario string

type PredictionType string

type ProjectedValue struct {
	Timestamp  time.Time
	Value      float64
	LowerBound float64
	UpperBound float64
}

type ROIAnalysis struct {
	Investment    float64
	Returns       float64
	PaybackPeriod time.Duration
	NPV           float64
	IRR           float64
}

type Recommendation struct {
	ID          string
	Title       string
	Description string
	Type        RecommendationType
	Priority    RecommendationPriority
	Steps       []RecommendationStep
	References  []string
	Tags        []string
	Effort      EffortEstimate
	Impact      ImpactEstimate
}

type RecommendationEngine interface {
	GenerateRecommendations(ctx context.Context, analysis AnalysisResult) ([]Recommendation, error)
	PrioritizeRecommendations(recommendations []Recommendation) []Recommendation
	EstimateImpact(recommendation Recommendation) ImpactEstimate
	ValidateRecommendation(recommendation Recommendation) ValidationResult
}

type RecommendationPriority string

type RecommendationStep struct {
	Description string
	Action      string
	Validation  string
	Rollback    string
	Order       int
}

type RecommendationType string

type Regression struct {
	Metric     string
	Severity   RegressionSeverity
	OldValue   float64
	NewValue   float64
	Change     float64
	Percentage float64
}

type RegressionSeverity string

type ResourceImpact struct {
	CPU     float64
	Memory  float64
	Storage float64
	Network float64
}

type ResourceRecommendation struct {
	Type     ResourceType
	Reason   string
	Current  ResourceSpec
	Proposed ResourceSpec
}

type ResourceSpec struct {
	Unit  string
	Type  string
	Value float64
}

type ResourceType string

type ResourceUsageStats struct {
	Memory  MemoryUsageStats
	CPU     CPUUsageStats
	Disk    DiskUsageStats
	Network NetworkUsageStats
}

type ResponseTimeStats struct {
	Min    time.Duration
	Max    time.Duration
	Mean   time.Duration
	Median time.Duration
	StdDev time.Duration
	P95    time.Duration
	P99    time.Duration
	P999   time.Duration
}

type RiskImpact struct {
	Stability   float64
	Security    float64
	Compliance  float64
	Operational float64
}

type RiskLevel string

type ScalingPhase struct {
	Name         string
	Actions      []string
	Milestones   []string
	Dependencies []string
	Duration     time.Duration
}

type ScalingPrediction struct {
	Recommendations []ScalingRecommendation
	Timeline        ScalingTimeline
	PredictedDemand DemandForecast
	CurrentCapacity CapacityMetrics
	ScalingNeeds    ScalingRequirements
	CostEstimate    CostEstimate
}

type ScalingPriority string

type ScalingRecommendation struct {
	Type        ScalingType
	Description string
	Risk        RiskLevel
	Resources   []ResourceRecommendation
	Benefits    []string
	Timeline    time.Duration
	Cost        float64
}

type ScalingRequirement struct {
	Priority ScalingPriority
	Current  float64
	Required float64
	Increase float64
	Timeline time.Duration
}

type ScalingRequirements struct {
	CPU     ScalingRequirement
	Memory  ScalingRequirement
	Storage ScalingRequirement
	Network ScalingRequirement
}

type ScalingTimeline struct {
	Phases []ScalingPhase
	Total  time.Duration
}

type ScalingType string

type SeasonalPattern struct {
	Period    time.Duration
	Amplitude float64
	Phase     time.Duration
}

type StatisticalSignificance struct {
	TestType    string
	PValue      float64
	Confidence  float64
	Significant bool
}

type TargetType string

type ThroughputStats struct {
	RequestsPerSecond float64
	BytesPerSecond    float64
	Peak              float64
	Average           float64
	Minimum           float64
}

type Trend struct {
	Metric     string
	Direction  TrendDirection
	Projection TrendProjection
	Slope      float64
	Confidence float64
	Duration   time.Duration
}

type TrendAnalysis struct {
	// slices (24 bytes each)
	Trends    []Trend
	Patterns  []PerformancePattern
	Anomalies []Anomaly
	// time.Time (24 bytes)
	Timestamp time.Time
	// struct
	Summary TrendSummary
	// 8-byte aligned fields
	Period     time.Duration
	Confidence float64
}

type TrendAnalyzer interface {
	AnalyzeTrends(ctx context.Context, metrics []PerformanceMetrics) (TrendAnalysis, error)
	PredictTrends(ctx context.Context, historical []PerformanceMetrics, horizon time.Duration) (TrendPrediction, error)
	DetectAnomalies(ctx context.Context, metrics []PerformanceMetrics) ([]Anomaly, error)
	GenerateTrendReport(analysis TrendAnalysis) TrendReport
}

type TrendDirection string

type TrendInsight struct {
	Type        InsightType
	Description string
	Impact      ImpactLevel
	Evidence    []string
	Actions     []string
	Confidence  float64
}

type TrendPrediction struct {
	Methodology string
	Predictions []Prediction
	Scenarios   []PredictionScenario
	Assumptions []string
	TimeHorizon time.Duration
	Confidence  float64
}

type TrendProjection struct {
	Values      []ProjectedValue
	TimeHorizon time.Duration
	Confidence  float64
}

type TrendReport struct {
	Timestamp       time.Time
	Insights        []TrendInsight
	Recommendations []Recommendation
	Predictions     TrendPrediction
	Analysis        TrendAnalysis
}

type TrendSummary struct {
	OverallDirection TrendDirection
	Seasonality      []SeasonalPattern
	KeyInsights      []string
	Stability        float64
	Volatility       float64
}

type ValidationIssue struct {
	Type        IssueType
	Severity    IssueSeverity
	Description string
	Impact      string
	Resolution  string
}

type ValidationResult struct {
	Issues      []ValidationIssue
	Warnings    []string
	Suggestions []string
	Score       float64
	Valid       bool
}