performance

package

Go to main page

Versions in this module

v0

v0.12.0

Jun 23, 2026

v0.10.0

May 4, 2026

v0.9.0

May 2, 2026

v0.8.1

Feb 18, 2026

v0.8.0

Feb 12, 2026

v0.7.1

Aug 13, 2025

v0.7.0

Aug 13, 2025

v0.6.2-security-analysis

Jul 3, 2025

v0.6.1

Jul 3, 2025

v0.6.0

Jul 3, 2025

v0.5.0

Jun 20, 2025

v0.4.0

Jun 20, 2025

v0.3.0

Jun 20, 2025

Changes in this version

+ type CacheSchedulerMetrics struct

+ JobsProcessed int64

+ JobsQueued int64

+ QueueDepth int

type ConcurrencyMetrics

+ AverageLatency time.Duration

+ IdleWorkers int64

+ ResourceUtilization ResourceStats

+ TasksFailed int64

+ TasksProcessed int64

+ TasksQueued int64

+ Throughput float64

+ TotalWorkers int64

type CoordinatorConfig

+ DiscoveryInterval time.Duration

+ EnableDiscovery bool

type InvalidationStrategy

+ const InvalidationCallbackStrategy

+ type LoadBalancerDataPoint struct

+ Features map[string]float64

+ Timestamp time.Time

+ Value float64

type SchedulerMetrics

+ TasksScheduled int64

type TargetStatistics

+ SuccessRate float64

type Task

+ GetTimeout func() time.Duration

+ GetType func() string

+ OnCancel func()

+ OnComplete func(result interface{}, err error)

type WorkerPoolConfig

+ ScalingInterval time.Duration

v0.2.0

Jun 20, 2025

Changes in this version

+ type AccessPattern struct

+ AccessTimes []time.Time

+ Frequency float64

+ Key string

+ LastAccess time.Time

+ PredictedNext time.Time

+ type AccessPredictor struct

+ func (ap *AccessPredictor) RecordAccess(key string)

+ type AdvancedLoadBalancer struct

+ func NewAdvancedLoadBalancer(config LoadBalancerConfig, logger Logger) *AdvancedLoadBalancer

+ func (lb *AdvancedLoadBalancer) AddTarget(target *LoadBalanceTarget) error

+ func (lb *AdvancedLoadBalancer) GetMetrics() *LoadBalancerMetrics

+ func (lb *AdvancedLoadBalancer) RecordRequest(targetID string, latency time.Duration, success bool)

+ func (lb *AdvancedLoadBalancer) RemoveTarget(targetID string) error

+ func (lb *AdvancedLoadBalancer) SelectTarget(request *BalanceRequest) (*LoadBalanceTarget, error)

+ func (lb *AdvancedLoadBalancer) Start() error

+ func (lb *AdvancedLoadBalancer) Stop() error

+ type AffinityRule struct

+ Key string

+ Operator string

+ Values []string

+ Weight int

type Alert

+ Metadata map[string]interface{}

+ Resolved bool

+ ResolvedAt *time.Time

+ Timestamp time.Time

+ Title string

+ type AlertChannel interface

+ GetName func() string

+ Send func(alert *Alert) error

+ type AlertCondition string

+ const AlertConditionChange

+ const AlertConditionEquals

+ const AlertConditionGreaterThan

+ const AlertConditionLessThan

+ type AlertConfig struct

+ AlertRetention time.Duration

+ CheckInterval time.Duration

+ DefaultChannels []string

+ MaxAlerts int

+ type AlertManager struct

+ func NewAlertManager(config AlertConfig, logger Logger) *AlertManager

+ func (am *AlertManager) CheckAlerts(metrics *PerformanceMetrics)

+ func (am *AlertManager) GetActiveAlerts() []*Alert

+ func (am *AlertManager) Start() error

+ func (am *AlertManager) Stop() error

+ type AlertMessage struct

+ Message string

+ Metadata map[string]interface{}

+ Severity string

+ Source string

+ Timestamp time.Time

+ Title string

+ Type string

+ type AlertMetrics struct

+ AlertsResolved int64

+ AlertsTriggered int64

+ FalsePositives int64

+ ResponseTime time.Duration

type AlertRule

+ Condition AlertCondition

+ Enabled bool

+ Metadata map[string]interface{}

+ type AnalyzerConfig struct

+ AnalysisInterval time.Duration

+ HotspotThreshold float64

+ IssueDetectionDepth int

+ TrendWindowSize int

+ type AnalyzerMetrics struct

+ AnalysisAccuracy float64

+ HotspotsDetected int64

+ IssuesFound int64

+ TrendsAnalyzed int64

+ type ApplicationMetrics struct

+ ActiveConnections int

+ AverageLatency time.Duration

+ ErrorRate float64

+ P95Latency time.Duration

+ P99Latency time.Duration

+ QueueDepth int

+ RequestsPerSecond float64

+ type AutoScalingConfig struct

+ Enabled bool

+ EvaluationInterval time.Duration

+ MaxTargets int

+ MinTargets int

+ PredictiveScaling bool

+ ScaleDownCooldown time.Duration

+ ScaleDownThreshold float64

+ ScaleUpCooldown time.Duration

+ ScaleUpThreshold float64

+ ScalingPolicies []ScalingPolicy

+ type BalanceRequest struct

+ Key string

+ Metadata map[string]string

+ Preferences map[string]interface{}

+ Strategy string

+ type BalanceTarget struct

+ Active bool

+ Address string

+ ID string

+ Load float64

+ Weight int

+ type BalancerConfig struct

+ FailureThreshold int

+ HealthCheckInterval time.Duration

+ RecoveryTimeout time.Duration

+ Strategy BalancingStrategy

+ type BalancerMetrics struct

+ ActiveTargets int

+ RequestsBalanced int64

+ type BalancingStrategy string

+ const BalancingAdaptive

+ const BalancingConsistent

+ const BalancingLeastActive

+ const BalancingRoundRobin

+ const BalancingWeighted

+ type Benchmark struct

+ Config BenchmarkConfig

+ Description string

+ Enabled bool

+ Function BenchmarkFunction

+ Name string

+ Results []*BenchmarkResult

+ type BenchmarkConfig struct

+ Duration time.Duration

+ Iterations int

+ Parallel bool

+ WarmupRounds int

+ type BenchmarkFunction func() BenchmarkResult

+ type BenchmarkResult struct

+ AllocsPerOp int64

+ BytesPerOp int64

+ Duration time.Duration

+ Error string

+ Iterations int

+ MemoryUsed int64

+ NsPerOp int64

+ Success bool

+ Timestamp time.Time

+ type BlockProfiler struct

+ func (bp *BlockProfiler) Collect() (*ProfileData, error)

+ func (bp *BlockProfiler) GetName() string

+ func (bp *BlockProfiler) IsEnabled() bool

+ func (bp *BlockProfiler) Start() error

+ func (bp *BlockProfiler) Stop() error

+ type ByteSliceFactory struct

+ Size int

+ func NewByteSliceFactory(size int) *ByteSliceFactory

+ func (f *ByteSliceFactory) CreateObject() interface{}

+ func (f *ByteSliceFactory) GetObjectType() string

+ type ByteSliceReset struct

+ func (r *ByteSliceReset) ResetObject(obj interface{}) error

+ type CPUMetrics struct

+ IdleTime time.Duration

+ LoadAverage []float64

+ SystemTime time.Duration

+ Usage float64

+ UserTime time.Duration

+ type CPUProfiler struct

+ func (cp *CPUProfiler) Collect() (*ProfileData, error)

+ func (cp *CPUProfiler) GetName() string

+ func (cp *CPUProfiler) IsEnabled() bool

+ func (cp *CPUProfiler) Start() error

+ func (cp *CPUProfiler) Stop() error

type CacheEntry

+ AccessCount int64

+ Compressed bool

+ Key string

+ Metadata map[string]interface{}

+ TTL time.Duration

+ Tags []string

+ type CacheInvalidator struct

+ func NewCacheInvalidator(config CacheInvalidatorConfig, logger Logger) *CacheInvalidator

+ func (ci *CacheInvalidator) InvalidateByTags(tags []string) error

+ func (ci *CacheInvalidator) Start() error

+ func (ci *CacheInvalidator) Stop() error

+ type CacheInvalidatorConfig struct

+ BatchSize int

+ MaxTagsPerKey int

+ Strategies []InvalidationStrategy

+ TTLCheckInterval time.Duration

type CacheMetrics

+ AverageLatency time.Duration

+ Deletes int64

+ HitRatio float64

+ Hits int64

+ Misses int64

+ PartitionMetrics []*PartitionMetrics

+ Sets int64

+ TotalKeys int64

+ TotalSize int64

+ type CachePartition struct

+ Health PartitionHealth

+ ID int

+ KeyRange KeyRange

+ Load float64

+ Node string

+ type CachePartitioner struct

+ func NewCachePartitioner(config CachePartitionerConfig, strategy PartitionStrategy, count int, ...) *CachePartitioner

+ func (cp *CachePartitioner) GetPartition(key string) *CachePartition

+ func (cp *CachePartitioner) GetPartitionMetrics() []*PartitionMetrics

+ func (cp *CachePartitioner) Start() error

+ func (cp *CachePartitioner) Stop() error

+ type CachePartitionerConfig struct

+ HealthCheckInterval time.Duration

+ MigrationBatchSize int

+ RebalanceInterval time.Duration

+ RebalanceThreshold float64

+ type CacheWarmer struct

+ func NewCacheWarmer(config CacheWarmerConfig, cache *RedisClusterCache, logger Logger) *CacheWarmer

+ func (cw *CacheWarmer) Start() error

+ func (cw *CacheWarmer) Stop() error

+ type CacheWarmerConfig struct

+ BatchSize int

+ ConcurrentWorkers int

+ MinAccessThreshold int64

+ PredictionWindow time.Duration

+ Strategies []string

+ WarmingInterval time.Duration

+ type CircuitBreaker struct

+ func NewCircuitBreaker(config CircuitBreakerConfig, logger Logger) *CircuitBreaker

+ func (cb *CircuitBreaker) RecordRequest(targetID string, success bool)

+ type CircuitBreakerConfig struct

+ Enabled bool

+ FailureRate float64

+ FailureThreshold int

+ HalfOpenMaxRequests int

+ MinimumRequests int

+ SlidingWindowSize int

+ SuccessThreshold int

+ Timeout time.Duration

+ type CircuitBreakerMetrics struct

+ OpenCircuits int

+ TotalRequests int64

+ TrippedEvents int64

+ type CircuitBreakerSettings struct

+ FailureThreshold int

+ HalfOpenRequests int

+ RecoveryTimeout time.Duration

+ type CircuitState string

+ const CircuitClosed

+ const CircuitHalfOpen

+ const CircuitOpen

+ type ClientPermissions struct

+ ExportData bool

+ ManageAlerts bool

+ ReadMetrics bool

+ WriteConfig bool

+ type ClusterNode struct

+ Address string

+ Capabilities []string

+ HealthScore float64

+ ID string

+ LastHeartbeat time.Time

+ Load NodeLoadInfo

+ Metadata map[string]interface{}

+ Performance NodePerformance

+ Resources NodeResources

+ Role NodeRole

+ Status NodeStatus

+ TasksAssigned int64

+ TasksCompleted int64

+ TasksFailed int64

+ Version string

+ type ClusterStatus struct

+ Consensus ConsensusState

+ Leader string

+ Metrics *CoordinatorMetrics

+ Nodes map[string]*ClusterNode

+ Tasks []*DistributedTask

+ Term int64

type ConcurrencyEngine

+ func (e *ConcurrencyEngine) CreateWorkerPool(config WorkerPoolConfig, processor TaskProcessor) (*WorkerPool, error)

+ func (e *ConcurrencyEngine) SubmitTask(task Task) error

+ func (e *ConcurrencyEngine) SubmitTasks(tasks []Task) error

+ type ConcurrencyEngineConfig struct

+ BalancingStrategy BalancingStrategy

+ CPUThreshold float64

+ CircuitBreakerConfig CircuitBreakerSettings

+ CoordinationMode CoordinationMode

+ DefaultPoolSize int

+ EnableAdaptiveScaling bool

+ EnableCoordination bool

+ EnableMetrics bool

+ HealthCheckInterval time.Duration

+ HeartbeatInterval time.Duration

+ MaxQueueSize int

+ MaxWorkers int

+ MemoryThreshold float64

+ MetricsInterval time.Duration

+ MinWorkers int

+ PriorityLevels int

+ ScalingInterval time.Duration

+ SchedulingAlgorithm SchedulingAlgorithm

+ TaskTimeout time.Duration

+ WorkerIdleTimeout time.Duration

+ func DefaultConcurrencyEngineConfig() ConcurrencyEngineConfig

+ type ConsensusAlgorithm string

+ const ConsensusPBFT

+ const ConsensusPaxos

+ const ConsensusRaft

+ const ConsensusSimple

+ type ConsensusConfig struct

+ Algorithm ConsensusAlgorithm

+ ProposalTimeout time.Duration

+ QuorumSize int

+ VotingTimeout time.Duration

+ type ConsensusLog struct

+ type ConsensusManager struct

+ func NewConsensusManager(config ConsensusConfig, redis *redis.Client, logger Logger) *ConsensusManager

+ func (cm *ConsensusManager) GetState() ConsensusState

+ func (cm *ConsensusManager) Start() error

+ func (cm *ConsensusManager) Stop() error

+ type ConsensusMetrics struct

+ type ConsensusState string

+ type ConsistentHashRing struct

+ type CoordinationMode string

+ const CoordinationDistributed

+ const CoordinationHybrid

+ const CoordinationLocal

+ type CoordinatorConfig struct

+ BatchSize int

+ BatchTimeout time.Duration

+ ClusterName string

+ ConsensusTimeout time.Duration

+ ElectionTimeout time.Duration

+ EnableBatching bool

+ EnableCompression bool

+ EnableFailover bool

+ EnableMetrics bool

+ EnableTracing bool

+ FailoverTimeout time.Duration

+ HeartbeatInterval time.Duration

+ LoadBalancingStrategy LoadBalanceStrategy

+ MaxRetries int

+ MetricsInterval time.Duration

+ NodeID string

+ NodeTimeout time.Duration

+ PartitionStrategy PartitionStrategy

+ RedisAddr string

+ RedisDB int

+ RedisPassword string

+ Region string

+ ReplicationFactor int

+ RetryBackoff time.Duration

+ TaskPartitioning bool

+ Zone string

+ func DefaultCoordinatorConfig() CoordinatorConfig

+ type CoordinatorMetrics struct

+ ActiveNodes int64

+ AverageLatency time.Duration

+ ConsensusDecisions int64

+ ElectionCount int64

+ FailoverEvents int64

+ TasksCompleted int64

+ TasksDistributed int64

+ TasksFailed int64

+ Throughput float64

+ TotalNodes int64

+ type DashboardClient struct

+ Conn *websocket.Conn

+ ID string

+ LastSeen time.Time

+ Permissions ClientPermissions

+ Subscriptions []string

+ type DashboardConfig struct

+ AdminToken string

+ ClientTimeout time.Duration

+ EnableAlerts bool

+ EnableAuth bool

+ EnableDebug bool

+ EnableExport bool

+ EnableTLS bool

+ HistoryDuration time.Duration

+ Host string

+ MaxClients int

+ MaxDataPoints int

+ Port int

+ ReadOnlyToken string

+ TLSCertFile string

+ TLSKeyFile string

+ UpdateInterval time.Duration

+ func DefaultDashboardConfig() DashboardConfig

+ type DashboardMetrics struct

+ AverageLatency time.Duration

+ ConnectedClients int64

+ DataPointsStreamed int64

+ ErrorCount int64

+ MessagesReceived int64

+ MessagesSent int64

+ TotalConnections int64

+ type DataPoint struct

+ Timestamp time.Time

+ Value float64

+ type DefaultLogger struct

+ func NewDefaultLogger() *DefaultLogger

+ func (l *DefaultLogger) Debug(msg string, args ...interface{})

+ func (l *DefaultLogger) Error(msg string, args ...interface{})

+ func (l *DefaultLogger) Info(msg string, args ...interface{})

+ func (l *DefaultLogger) Warn(msg string, args ...interface{})

+ type DiskMetrics struct

+ BytesRead int64

+ BytesWritten int64

+ ReadOps int64

+ Usage float64

+ WriteOps int64

+ type DistributedExecutionCoordinator struct

+ func NewDistributedExecutionCoordinator(config CoordinatorConfig, logger Logger) (*DistributedExecutionCoordinator, error)

+ func (c *DistributedExecutionCoordinator) CancelTask(taskID string) error

+ func (c *DistributedExecutionCoordinator) GetClusterStatus() *ClusterStatus

+ func (c *DistributedExecutionCoordinator) GetMetrics() *CoordinatorMetrics

+ func (c *DistributedExecutionCoordinator) GetTaskStatus(taskID string) (*DistributedTask, error)

+ func (c *DistributedExecutionCoordinator) Start() error

+ func (c *DistributedExecutionCoordinator) Stop() error

+ func (c *DistributedExecutionCoordinator) SubmitBatch(tasks []*DistributedTask) error

+ func (c *DistributedExecutionCoordinator) SubmitTask(task *DistributedTask) error

+ type DistributedExecutor struct

+ type DistributedRateLimitConfig struct

+ Algorithm RateLimitAlgorithm

+ CleanupInterval time.Duration

+ DefaultBurst int64

+ DefaultLimit int64

+ DefaultWindow time.Duration

+ EnableMetrics bool

+ EnablePipelining bool

+ KeyExpiration time.Duration

+ KeyPrefix string

+ MaxRetries int

+ MetricsInterval time.Duration

+ RedisAddr string

+ RedisDB int

+ RedisPassword string

+ RetryDelay time.Duration

+ SlidingWindowParts int

+ func DefaultDistributedRateLimitConfig() DistributedRateLimitConfig

+ type DistributedRateLimiter struct

+ func NewDistributedRateLimiter(config DistributedRateLimitConfig, logger Logger) (*DistributedRateLimiter, error)

+ func (d *DistributedRateLimiter) Allow(request *RateLimitRequest) (*RateLimitResult, error)

+ func (d *DistributedRateLimiter) AllowN(key string, n int64) (*RateLimitResult, error)

+ func (d *DistributedRateLimiter) GetMetrics() *RateLimitMetrics

+ func (d *DistributedRateLimiter) GetStatus(key string) (*RateLimitResult, error)

+ func (d *DistributedRateLimiter) Reset(key string) error

+ func (d *DistributedRateLimiter) Start() error

+ func (d *DistributedRateLimiter) Stop() error

+ type DistributedScheduler struct

+ type DistributedTask struct

+ AssignedNode string

+ CompletedAt *time.Time

+ Constraints TaskConstraints

+ CreatedAt time.Time

+ Dependencies []string

+ Error string

+ ID string

+ MaxRetries int

+ Metadata map[string]interface{}

+ Partitions []TaskPartition

+ Payload map[string]interface{}

+ Priority int

+ Requirements TaskRequirements

+ Result interface{}

+ RetryCount int

+ StartedAt *time.Time

+ Status TaskStatus

+ Timeout time.Duration

+ Type string

+ type ElectionConfig struct

+ ElectionTimeout time.Duration

+ HeartbeatTimeout time.Duration

+ MaxTerms int64

+ TermTimeout time.Duration

+ type ElectionMetrics struct

+ ElectionsHeld int64

+ type ExecutionPipeline struct

+ func NewExecutionPipeline(config PipelineConfig, stages []StageProcessor, logger Logger) *ExecutionPipeline

+ func (ep *ExecutionPipeline) Start() error

+ func (ep *ExecutionPipeline) Stop() error

+ type ExecutorMetrics struct

+ ExecutionTime time.Duration

+ JobsExecuted int64

+ SuccessRate float64

+ type GCMetrics struct

+ GCCPUFraction float64

+ LastGC time.Time

+ NumForcedGC uint32

+ NumGC uint32

+ PauseNs []uint64

+ PauseTotal time.Duration

+ type GCStats struct

+ HeapObjects uint64

+ HeapSize uint64

+ LastPause time.Duration

+ NumGC uint32

+ PauseTotal time.Duration

+ type GoroutineMetrics struct

+ Blocked int

+ Count int

+ MaxCreated int64

+ Running int

+ TotalCreated int64

+ Waiting int

+ type GoroutineProfiler struct

+ func (gp *GoroutineProfiler) Collect() (*ProfileData, error)

+ func (gp *GoroutineProfiler) GetName() string

+ func (gp *GoroutineProfiler) IsEnabled() bool

+ func (gp *GoroutineProfiler) Start() error

+ func (gp *GoroutineProfiler) Stop() error

+ type HealthCheck struct

+ Body string

+ Endpoint string

+ ExpectedCode int

+ Headers map[string]string

+ Interval time.Duration

+ Method string

+ Retries int

+ Timeout time.Duration

+ Type HealthCheckType

+ type HealthCheckType string

+ const HealthCheckCustom

+ const HealthCheckHTTP

+ const HealthCheckPing

+ const HealthCheckTCP

+ type HealthChecker struct

+ type HealthMetrics struct

+ AverageLatency time.Duration

+ FailedChecks int64

+ SuccessfulChecks int64

+ TotalChecks int64

+ type HealthMonitor struct

+ func NewHealthMonitor(config HealthMonitorConfig, logger Logger) *HealthMonitor

+ func (hm *HealthMonitor) AddTarget(target *LoadBalanceTarget)

+ func (hm *HealthMonitor) RemoveTarget(target *LoadBalanceTarget)

+ func (hm *HealthMonitor) Start() error

+ func (hm *HealthMonitor) Stop() error

+ type HealthMonitorConfig struct

+ CheckInterval time.Duration

+ Enabled bool

+ HealthyThreshold int

+ MaxConcurrentChecks int

+ Timeout time.Duration

+ UnhealthyThreshold int

+ type HeartbeatManager struct

+ type Hotspot struct

+ AverageTime time.Duration

+ CPUPercent float64

+ CallCount int64

+ File string

+ Function string

+ Line int

+ MemoryBytes int64

+ Severity Severity

+ TotalTime time.Duration

+ type InvalidationCallback func(key string, entry *CacheEntry, reason string)

+ type InvalidationHandler interface

+ Invalidate func(key string, entry *CacheEntry) error

+ ShouldInvalidate func(entry *CacheEntry) bool

+ type InvalidationStrategy string

+ const InvalidationLRU

+ const InvalidationTTL

+ const InvalidationTags

+ type InvalidatorMetrics struct

+ Invalidations int64

+ ManualEvictions int64

+ TTLExpired int64

+ TagInvalidations int64

+ type IssueType string

+ const IssueTypeCPU

+ const IssueTypeDeadlock

+ const IssueTypeGC

+ const IssueTypeGoroutineLeak

+ const IssueTypeLatency

+ const IssueTypeMemory

+ const IssueTypeThroughput

+ type KeyRange struct

+ End uint32

+ Start uint32

+ type LeaderElection struct

+ func NewLeaderElection(config ElectionConfig, redis *redis.Client, logger Logger) *LeaderElection

+ func (le *LeaderElection) GetCurrentLeader() string

+ func (le *LeaderElection) GetCurrentTerm() int64

+ func (le *LeaderElection) HasLeader() bool

+ func (le *LeaderElection) IsElectionInProgress() bool

+ func (le *LeaderElection) IsLeader() bool

+ func (le *LeaderElection) Start() error

+ func (le *LeaderElection) StartElection()

+ func (le *LeaderElection) Stop() error

+ type LoadBalanceStrategy string

+ const LoadBalanceCapability

+ const LoadBalanceLatency

+ const LoadBalanceLeastLoaded

type LoadBalanceTarget

+ Capabilities []string

+ CircuitState CircuitState

+ CurrentLoad int64

+ HealthStatus TargetHealthStatus

+ LastHealthCheck time.Time

+ MaxConcurrency int

+ ResponseTime time.Duration

+ Statistics *TargetStatistics

+ SuccessRate float64

+ type LoadBalancer struct

+ func (lb *LoadBalancer) Start() error

+ func (lb *LoadBalancer) Stop() error

+ type LoadBalancerConfig struct

+ AutoScaling AutoScalingConfig

+ CircuitBreaker CircuitBreakerConfig

+ DefaultStrategy BalancingStrategy

+ EnableHealthChecks bool

+ EnableMetrics bool

+ EnablePredictive bool

+ EnableStickySessions bool

+ EnableWeighting bool

+ HealthCheckInterval time.Duration

+ LoadPrediction LoadPredictionConfig

+ MaxConcurrentChecks int

+ MetricsInterval time.Duration

+ Name string

+ RequestTimeout time.Duration

+ RetryAttempts int

+ RetryDelay time.Duration

+ SessionTimeout time.Duration

+ WeightAdjustment WeightConfig

+ func DefaultLoadBalancerConfig() LoadBalancerConfig

+ type LoadBalancerMetrics struct

+ ActiveTargets int

+ AverageLatency time.Duration

+ CircuitBreakerTrips int64

+ FailedRequests int64

+ HealthyTargets int

+ RequestsPerSecond float64

+ ScalingEvents int64

+ SuccessfulRequests int64

+ TargetMetrics map[string]*TargetStatistics

+ TotalRequests int64

+ type LoadDataPoint struct

+ Latency time.Duration

+ Load float64

+ Targets int

+ Timestamp time.Time

+ type LoadForecast struct

+ Algorithm PredictionAlgorithm

+ Confidence float64

+ GeneratedAt time.Time

+ Predictions []PredictionPoint

+ type LoadHistory struct

+ DataPoints []LoadDataPoint

+ type LoadPredictionConfig struct

+ Algorithm PredictionAlgorithm

+ ConfidenceThreshold float64

+ Enabled bool

+ HistoryDuration time.Duration

+ PredictionHorizon time.Duration

+ SeasonalityDetection bool

+ TrendAnalysis bool

+ UpdateInterval time.Duration

type LoadPredictor

+ func NewLoadPredictor(config LoadPredictionConfig, logger Logger) *LoadPredictor

+ func (lp *LoadPredictor) Start() error

+ func (lp *LoadPredictor) Stop() error

+ type MapFactory struct

+ InitialSize int

+ func NewMapFactory(initialSize int) *MapFactory

+ func (f *MapFactory) CreateObject() interface{}

+ func (f *MapFactory) GetObjectType() string

+ type MapReset struct

+ func (r *MapReset) ResetObject(obj interface{}) error

+ type MemoryMetrics struct

+ Allocated uint64

+ BuckHashSys uint64

+ Frees uint64

+ GCSys uint64

+ HeapAlloc uint64

+ HeapIdle uint64

+ HeapInuse uint64

+ HeapObjects uint64

+ HeapReleased uint64

+ HeapSys uint64

+ Lookups uint64

+ MCacheInuse uint64

+ MCacheSys uint64

+ MSpanInuse uint64

+ MSpanSys uint64

+ Mallocs uint64

+ NextGC uint64

+ OtherSys uint64

+ StackInuse uint64

+ StackSys uint64

+ Sys uint64

+ TotalAlloc uint64

+ type MemoryPoolConfig struct

+ CleanupInterval time.Duration

+ DefaultPoolSize int

+ EnableGCOptimization bool

+ EnableMetrics bool

+ GCTarget int

+ MaxMemoryUsage int64

+ MaxObjectAge time.Duration

+ MaxPoolSize int

+ MetricsInterval time.Duration

+ MinPoolSize int

+ PreallocationSize int

+ func DefaultMemoryPoolConfig() MemoryPoolConfig

+ type MemoryPoolManager struct

+ func NewMemoryPoolManager(config MemoryPoolConfig, logger Logger) *MemoryPoolManager

+ func (m *MemoryPoolManager) CreatePool(name string, factory ObjectFactory, reset ObjectReset) (*ObjectPool, error)

+ func (m *MemoryPoolManager) Get(poolName string) (interface{}, error)

+ func (m *MemoryPoolManager) GetMetrics() *MemoryPoolMetrics

+ func (m *MemoryPoolManager) GetPool(name string) (*ObjectPool, error)

+ func (m *MemoryPoolManager) GetPoolMetrics() []*ObjectPoolMetrics

+ func (m *MemoryPoolManager) Put(poolName string, obj interface{}) error

+ func (m *MemoryPoolManager) Start() error

+ func (m *MemoryPoolManager) Stop() error

+ type MemoryPoolMetrics struct

+ AverageObjectAge time.Duration

+ MemoryAllocated int64

+ MemoryReleased int64

+ ObjectsCreated int64

+ ObjectsDestroyed int64

+ ObjectsReused int64

+ PoolHitRate float64

+ TotalObjects int64

+ TotalPools int64

type MemoryProfiler

+ func (mp *MemoryProfiler) Collect() (*ProfileData, error)

+ func (mp *MemoryProfiler) GetName() string

+ func (mp *MemoryProfiler) IsEnabled() bool

+ func (mp *MemoryProfiler) Start() error

+ func (mp *MemoryProfiler) Stop() error

type MetricsCollector

+ GetName func() string

+ IsEnabled func() bool

+ type MetricsMessage struct

+ Metrics map[string]interface{}

+ Source string

+ Timestamp time.Time

+ Type string

type MonitoringDashboard

+ func NewMonitoringDashboard(config DashboardConfig, logger Logger) *MonitoringDashboard

+ func (d *MonitoringDashboard) AddMetricsCollector(collector MetricsCollector)

+ func (d *MonitoringDashboard) BroadcastAlert(alert AlertMessage)

+ func (d *MonitoringDashboard) GetMetrics() *DashboardMetrics

+ func (d *MonitoringDashboard) RemoveMetricsCollector(name string)

+ func (d *MonitoringDashboard) Start() error

+ func (d *MonitoringDashboard) Stop() error

+ type MutexProfiler struct

+ func (mp *MutexProfiler) Collect() (*ProfileData, error)

+ func (mp *MutexProfiler) GetName() string

+ func (mp *MutexProfiler) IsEnabled() bool

+ func (mp *MutexProfiler) Start() error

+ func (mp *MutexProfiler) Stop() error

+ type NetworkMetrics struct

+ BytesReceived int64

+ BytesSent int64

+ Connections int

+ PacketsReceived int64

+ PacketsSent int64

+ type NodeInfo struct

+ Address string

+ Capabilities []string

+ ID string

+ LastSeen time.Time

+ Load NodeLoad

+ Metadata map[string]interface{}

+ Status NodeStatus

+ type NodeLoad struct

+ CPU float64

+ Memory float64

+ Network float64

+ QueueDepth int

+ TaskCount int

+ type NodeLoadInfo struct

+ ActiveTasks int

+ CPUUsage float64

+ DiskUsage float64

+ MemoryUsage float64

+ NetworkUsage float64

+ QueuedTasks int

+ ThroughputRPS float64

+ type NodeManager struct

+ func NewNodeManager(config NodeManagerConfig, redis *redis.Client, logger Logger) *NodeManager

+ func (nm *NodeManager) CheckNodeHealth()

+ func (nm *NodeManager) GetActiveNodeCount() int

+ func (nm *NodeManager) GetNodes() map[string]*ClusterNode

+ func (nm *NodeManager) Start() error

+ func (nm *NodeManager) Stop() error

+ type NodeManagerConfig struct

+ DiscoveryInterval time.Duration

+ HealthCheckInterval time.Duration

+ MaxNodes int

+ NodeTimeout time.Duration

+ type NodeMetrics struct

+ HealthChecks int64

+ HeartbeatsLost int64

+ NodesJoined int64

+ NodesLeft int64

+ type NodePerformance struct

+ Availability float64

+ AverageLatency time.Duration

+ ErrorRate float64

+ LastUpdate time.Time

+ P95Latency time.Duration

+ P99Latency time.Duration

+ SuccessRate float64

+ type NodeResources struct

+ CPU int

+ Disk int64

+ MaxTasks int

+ Memory int64

+ Network int64

+ Specialized map[string]int

+ type NodeRole string

+ const NodeRoleCandidate

+ const NodeRoleFollower

+ const NodeRoleLeader

+ const NodeRoleObserver

+ type NodeStatus string

+ const NodeStatusDegraded

+ const NodeStatusHealthy

+ const NodeStatusUnavailable

+ const NodeStatusUnhealthy

+ type ObjectFactory interface

+ CreateObject func() interface{}

+ GetObjectType func() string

type ObjectPool

+ func (p *ObjectPool) GetMetrics() *ObjectPoolMetrics

+ func (p *ObjectPool) Stop()

+ type ObjectPoolMetrics struct

+ AverageAge time.Duration

+ HitRate float64

+ LastCleanup time.Time

+ ObjectsCreated int64

+ ObjectsDestroyed int64

+ ObjectsReused int64

+ PoolName string

+ PoolSize int

+ type ObjectReset interface

+ ResetObject func(obj interface{}) error

type OptimizationResult

+ AfterMetrics *PerformanceMetrics

+ Applied bool

+ BeforeMetrics *PerformanceMetrics

+ Description string

+ Error string

+ Improvement float64

+ Parameters map[string]interface{}

+ Strategy string

+ Timestamp time.Time

+ type OptimizationStrategy interface

+ CanOptimize func(metrics *PerformanceMetrics) bool

+ GetName func() string

+ GetPriority func() int

+ Optimize func(metrics *PerformanceMetrics) (*OptimizationResult, error)

+ type OptimizerConfig struct

+ MaxOptimizations int

+ OptimizationInterval time.Duration

+ SafetyMode bool

+ Strategies []string

+ type OptimizerMetrics struct

+ LastOptimization time.Time

+ OptimizationsAttempted int64

+ OptimizationsSuccessful int64

+ PerformanceImprovement float64

+ type OrchestratorConfig struct

+ BatchSize int

+ EnableBatching bool

+ MaxConcurrentTasks int

+ RetryDelay time.Duration

+ TaskTimeout time.Duration

+ type OrchestratorMetrics struct

+ AverageExecution time.Duration

+ PartitionsCreated int64

+ QueueDepth int

+ TasksExecuted int64

+ TasksScheduled int64

+ type Partition struct

+ type PartitionConfig struct

+ DefaultStrategy PartitionStrategy

+ MaxPartitions int

+ MinPartitionSize int

+ RebalanceInterval time.Duration

+ type PartitionHealth string

+ const PartitionDegraded

+ const PartitionHealthy

+ const PartitionUnhealthy

+ type PartitionManager struct

+ func NewPartitionManager(config PartitionConfig, logger Logger) *PartitionManager

+ type PartitionMetrics struct

+ DataSize int64

+ Health PartitionHealth

+ KeyCount int64

+ Load float64

+ PartitionID int

+ type PartitionStatus string

+ const PartitionStatusAssigned

+ const PartitionStatusCancelled

+ const PartitionStatusCompleted

+ const PartitionStatusExecuting

+ const PartitionStatusFailed

+ const PartitionStatusPending

+ type PartitionStrategy string

+ const PartitionAdaptive

+ const PartitionByCapability

+ const PartitionByConsistent

+ const PartitionByHash

+ const PartitionByLoad

+ const PartitionByRange

+ type PartitionerMetrics struct

+ LoadVariance float64

+ Migrations int64

+ Rebalances int64

+ type PartitioningStrategy interface

type PerformanceAnalyzer

+ func (pa *PerformanceAnalyzer) AnalyzeMetrics(metrics *PerformanceMetrics)

+ func (pa *PerformanceAnalyzer) GetHotspots() []*Hotspot

+ func (pa *PerformanceAnalyzer) GetIssues() []*PerformanceIssue

+ type PerformanceIssue struct

+ Component string

+ Description string

+ DetectedAt time.Time

+ Impact float64

+ Metadata map[string]interface{}

+ Severity Severity

+ Suggestions []string

+ Title string

+ Type IssueType

type PerformanceMetrics

+ Application ApplicationMetrics

+ CPU CPUMetrics

+ Disk DiskMetrics

+ GC GCMetrics

+ Goroutines GoroutineMetrics

+ Memory MemoryMetrics

+ Network NetworkMetrics

+ Timestamp time.Time

+ type PerformanceOptimizer struct

+ func NewPerformanceOptimizer(config OptimizerConfig, logger Logger) *PerformanceOptimizer

+ func (po *PerformanceOptimizer) Start() error

+ func (po *PerformanceOptimizer) Stop() error

+ type PerformanceProfiler struct

+ func NewPerformanceProfiler(config ProfilerConfig, logger Logger) (*PerformanceProfiler, error)

+ func (p *PerformanceProfiler) CollectMetrics() *PerformanceMetrics

+ func (p *PerformanceProfiler) GenerateReport(period ReportPeriod) (*PerformanceReport, error)

+ func (p *PerformanceProfiler) GetMetrics() *ProfilerMetrics

+ func (p *PerformanceProfiler) Start() error

+ func (p *PerformanceProfiler) Stop() error

+ type PerformanceReport struct

+ GeneratedAt time.Time

+ Hotspots []*Hotspot

+ Issues []*PerformanceIssue

+ Metrics *PerformanceMetrics

+ Optimizations []*OptimizationResult

+ Period ReportPeriod

+ Recommendations []string

+ Summary *PerformanceSummary

+ Trends *TrendAnalysis

+ type PerformanceReporter struct

+ func NewPerformanceReporter(config ReporterConfig, logger Logger) *PerformanceReporter

+ func (pr *PerformanceReporter) GenerateReport(period ReportPeriod) (*PerformanceReport, error)

+ func (pr *PerformanceReporter) Start() error

+ func (pr *PerformanceReporter) Stop() error

+ type PerformanceSummary struct

+ CPUScore float64

+ CriticalIssues int

+ LatencyScore float64

+ MemoryScore float64

+ OverallScore float64

+ ThroughputScore float64

+ TotalIssues int

+ Uptime time.Duration

+ type PerformanceThresholds struct

+ MaxCPUUsage float64

+ MaxErrorRate float64

+ MaxGoroutines int

+ MaxLatency time.Duration

+ MaxMemoryUsage int64

+ MinThroughput float64

+ type PipelineConfig struct

+ BufferSize int

+ EnableParallel bool

+ MaxConcurrency int

+ Name string

+ Timeout time.Duration

+ type PipelineMetrics struct

+ AverageLatency time.Duration

+ TasksProcessed int64

+ type PipelineResult struct

+ Error error

+ Result interface{}

+ TaskID string

+ type PoolMetrics struct

+ ActiveTasks int64

+ AverageWaitTime time.Duration

+ CompletedTasks int64

+ FailedTasks int64

+ PoolName string

+ QueueDepth int

+ Throughput float64

+ WorkerCount int

+ type PooledObject struct

+ CreatedAt time.Time

+ LastUsed time.Time

+ Object interface{}

+ UsedCount int64

+ type PredictionAlgorithm string

+ const PredictionARIMA

+ const PredictionEnsemble

+ const PredictionExponentialSmoothing

+ const PredictionLinearRegression

+ const PredictionNeuralNetwork

+ type PredictionMetrics struct

+ LastUpdate time.Time

+ ModelConfidence float64

+ PredictionAccuracy float64

+ PredictionLatency time.Duration

+ type PredictionModel struct

+ Accuracy float64

+ Algorithm PredictionAlgorithm

+ LastTrained time.Time

+ Parameters map[string]float64

+ TrainingData []DataPoint

+ type PredictionPoint struct

+ Confidence float64

+ Timestamp time.Time

+ Value float64

+ type PredictorConfig struct

+ MinDataPoints int

+ PredictionHorizon time.Duration

+ WindowSize int

+ type PriorityQueue struct

+ type ProfileData struct

+ Data []byte

+ Duration time.Duration

+ FilePath string

+ Metadata map[string]interface{}

+ Size int64

+ Timestamp time.Time

+ Type string

+ type Profiler interface

+ Collect func() (*ProfileData, error)

+ GetName func() string

+ IsEnabled func() bool

+ Start func() error

+ Stop func() error

+ func NewBlockProfiler(dir string, logger Logger) Profiler

+ func NewCPUProfiler(dir string, logger Logger) Profiler

+ func NewGoroutineProfiler(dir string, logger Logger) Profiler

+ func NewMutexProfiler(dir string, logger Logger) Profiler

+ func NewTraceProfiler(dir string, logger Logger) Profiler

+ type ProfilerConfig struct

+ AlertsEnabled bool

+ AnalysisDepth int

+ AnalysisEnabled bool

+ AutoOptimization bool

+ EnableBlockProfiling bool

+ EnableCPUProfiling bool

+ EnableGoroutineProfiling bool

+ EnableMemoryProfiling bool

+ EnableMutexProfiling bool

+ EnableTraceProfiling bool

+ GCTuningEnabled bool

+ HotspotThreshold float64

+ MaxProfileFiles int

+ MemoryLeakThreshold int64

+ MetricsInterval time.Duration

+ OptimizationInterval time.Duration

+ OptimizationStrategies []string

+ PerformanceThresholds PerformanceThresholds

+ PoolOptimizationEnabled bool

+ ProfileRetention time.Duration

+ ProfilesDir string

+ ProfilingInterval time.Duration

+ ServerEnabled bool

+ ServerHost string

+ ServerPort int

+ func DefaultProfilerConfig() ProfilerConfig

+ type ProfilerMetrics struct

+ AlertsTriggered int64

+ AnalysesPerformed int64

+ AverageAnalysisTime time.Duration

+ IssuesDetected int64

+ OptimizationsApplied int64

+ ProfilesCollected int64

+ type Proposal struct

+ CreatedAt time.Time

+ Data map[string]interface{}

+ ExpiresAt time.Time

+ ID string

+ Proposer string

+ Status ProposalStatus

+ Term int64

+ Type ProposalType

+ Votes map[string]bool

+ type ProposalStatus string

+ type ProposalType string

+ const ProposalConfigChange

+ const ProposalLeaderElection

+ const ProposalNodeMembership

+ const ProposalResourceRebalance

+ const ProposalTaskAssignment

+ type RateLimitAlgorithm string

+ const AlgorithmFixedWindow

+ const AlgorithmLeakyBucket

+ const AlgorithmSlidingWindow

+ const AlgorithmTokenBucket

+ type RateLimitMetrics struct

+ ActiveKeys int64

+ AllowRate float64

+ AllowedRequests int64

+ AverageLatency time.Duration

+ DeniedRequests int64

+ RedisErrors int64

+ RedisOperations int64

+ TotalRequests int64

+ type RateLimitRequest struct

+ Burst int64

+ Cost int64

+ Key string

+ Limit int64

+ Timestamp time.Time

+ Window time.Duration

+ type RateLimitResult struct

+ Allowed bool

+ CurrentUsage int64

+ Remaining int64

+ ResetTime time.Time

+ RetryAfter time.Duration

+ TotalLimit int64

+ WindowSize time.Duration

+ type RateLimitScripts struct

+ Cleanup *redis.Script

+ FixedWindow *redis.Script

+ LeakyBucket *redis.Script

+ SlidingWindow *redis.Script

+ TokenBucket *redis.Script

+ type ReadPreference string

+ const ReadNearest

+ const ReadPreferReplica

+ const ReadPrimary

+ const ReadReplica

+ type RedisClusterCache struct

+ func NewRedisClusterCache(config RedisClusterCacheConfig, logger Logger) (*RedisClusterCache, error)

+ func (c *RedisClusterCache) Delete(key string) error

+ func (c *RedisClusterCache) Get(key string) (interface{}, error)

+ func (c *RedisClusterCache) GetMetrics() *CacheMetrics

+ func (c *RedisClusterCache) InvalidateByTags(tags []string) error

+ func (c *RedisClusterCache) Set(key string, value interface{}, ttl time.Duration, tags ...string) error

+ func (c *RedisClusterCache) Start() error

+ func (c *RedisClusterCache) Stop() error

+ type RedisClusterCacheConfig struct

+ CompressionEnabled bool

+ CompressionThreshold int64

+ ConsistentHashing bool

+ DefaultTTL time.Duration

+ EnableMetrics bool

+ EnableTracing bool

+ InvalidationStrategy InvalidationStrategy

+ MaxRedirects int

+ MaxTags int

+ MaxValueSize int64

+ MetricsInterval time.Duration

+ MinIdleConns int

+ PartitionCount int

+ PartitionStrategy PartitionStrategy

+ Password string

+ PipelineSize int

+ PoolSize int

+ PrimaryAddrs []string

+ ReadPreference ReadPreference

+ ReadTimeout time.Duration

+ ReplicaAddrs []string

+ ReplicationFactor int

+ TagsEnabled bool

+ WarmingBatchSize int

+ WarmingConcurrency int

+ WarmingEnabled bool

+ WarmingInterval time.Duration

+ WriteTimeout time.Duration

+ func DefaultRedisClusterCacheConfig() RedisClusterCacheConfig

+ type Replica struct

+ type ReplicationConfig struct

+ MaxSnapshots int

+ ReplicationFactor int

+ SnapshotInterval time.Duration

+ SyncTimeout time.Duration

+ type ReplicationManager struct

+ func NewReplicationManager(config ReplicationConfig, redis *redis.Client, logger Logger) *ReplicationManager

+ func (rm *ReplicationManager) Start() error

+ func (rm *ReplicationManager) Stop() error

+ type ReplicationMetrics struct

+ type ReportExporter interface

+ Export func(report []byte, format string, destination string) error

+ GetName func() string

+ type ReportPeriod struct

+ End time.Time

+ Start time.Time

+ type ReportTemplate interface

+ Generate func(data *PerformanceReport) ([]byte, error)

+ GetFormat func() string

+ GetName func() string

+ type ReporterConfig struct

+ ExportDestinations []string

+ HistoryRetention time.Duration

+ ReportFormats []string

+ ReportInterval time.Duration

+ type ReporterMetrics struct

+ ExportFailures int64

+ ReportsExported int64

+ ReportsGenerated int64

+ type ResourceStats struct

+ CPUUsage float64

+ GCStats GCStats

+ Goroutines int

+ MemoryUsage float64

+ type ScalingCondition struct

+ Duration time.Duration

+ Metric string

+ Operator ThresholdOperator

+ Value float64

+ type ScalingEvent struct

+ Metrics map[string]float64

+ Reason string

+ TargetCount int

+ Timestamp time.Time

+ Type ScalingType

+ type ScalingHistory struct

+ Events []ScalingEvent

+ type ScalingMetrics struct

+ CurrentTargets int

+ PredictionAccuracy float64

+ ScaleDownEvents int64

+ ScaleUpEvents int64

+ type ScalingPolicy struct

+ Conditions []ScalingCondition

+ Cooldown time.Duration

+ Metric string

+ Name string

+ Operator ThresholdOperator

+ Priority int

+ ScaleAmount int

+ Threshold float64

+ Type ScalingType

+ type ScalingTrigger struct

+ Active bool

+ LastTrigger time.Time

+ Policy *ScalingPolicy

+ type ScalingType string

+ const ScalingTypeDown

+ const ScalingTypePredictive

+ const ScalingTypeScheduled

+ const ScalingTypeUp

+ type SchedulerConfig struct

+ Algorithm SchedulingAlgorithm

+ EnablePreemption bool

+ PriorityLevels int

+ QueueTimeout time.Duration

+ type SchedulerMetrics struct

+ JobsProcessed int64

+ JobsQueued int64

+ QueueDepth int

+ type SchedulingAlgorithm string

+ const SchedulingAdaptive

+ const SchedulingFIFO

+ const SchedulingLeastLoad

+ const SchedulingPriority

+ const SchedulingRoundRobin

+ type ServiceDiscovery struct

+ type Severity string

+ const SeverityCritical

+ const SeverityHigh

+ const SeverityLow

+ const SeverityMedium

+ type Snapshot struct

+ type StageMetrics struct

+ AverageLatency time.Duration

+ StageName string

+ TasksProcessed int64

+ type StageProcessor interface

+ GetStageName func() string

+ IsParallel func() bool

+ ProcessStage func(ctx context.Context, task Task) (Task, error)

+ type StageWorker struct

+ type StringBuilderFactory struct

+ func (f *StringBuilderFactory) CreateObject() interface{}

+ func (f *StringBuilderFactory) GetObjectType() string

+ type StringBuilderReset struct

+ func (r *StringBuilderReset) ResetObject(obj interface{}) error

+ type TagIndex struct

+ func (ti *TagIndex) AddTags(key string, tags []string)

+ func (ti *TagIndex) RemoveKey(key string)

+ type TargetHealthStatus string

+ const TargetDegraded

+ const TargetHealthy

+ const TargetMaintenance

+ const TargetUnhealthy

+ const TargetUnknown

+ type TargetStatistics struct

+ AverageLatency time.Duration

+ ErrorRate float64

+ FailedRequests int64

+ LastUpdated time.Time

+ LatencyHistory []time.Duration

+ P95Latency time.Duration

+ P99Latency time.Duration

+ SuccessfulRequests int64

+ Throughput float64

+ TotalRequests int64

+ type TaskCache struct

+ type TaskConstraints struct

+ Affinity []AffinityRule

+ AntiAffinity []AffinityRule

+ Deadline *time.Time

+ MaxRetries int

+ NodeSelector map[string]string

+ Timeout time.Duration

+ Tolerance []Toleration

+ type TaskMonitor struct

+ type TaskOrchestrator struct

+ func NewTaskOrchestrator(config OrchestratorConfig, redis *redis.Client, logger Logger) *TaskOrchestrator

+ func (to *TaskOrchestrator) CancelTask(taskID string) error

+ func (to *TaskOrchestrator) GetActiveTasks() []*DistributedTask

+ func (to *TaskOrchestrator) GetTaskStatus(taskID string) (*DistributedTask, error)

+ func (to *TaskOrchestrator) RebalanceTasks()

+ func (to *TaskOrchestrator) Start() error

+ func (to *TaskOrchestrator) Stop() error

+ func (to *TaskOrchestrator) SubmitBatch(tasks []*DistributedTask) error

+ func (to *TaskOrchestrator) SubmitTask(task *DistributedTask) error

+ type TaskPartition struct

+ Data map[string]interface{}

+ Error string

+ ID string

+ Index int

+ Node string

+ Result interface{}

+ Status PartitionStatus

+ type TaskPartitioner struct

+ type TaskProcessor interface

+ CanProcess func(task Task) bool

+ GetCapacity func() int

+ GetLoad func() float64

+ Process func(ctx context.Context, task Task) (interface{}, error)

+ type TaskRecovery struct

+ type TaskRequirements struct

+ CPU float64

+ Capabilities []string

+ Disk int64

+ Isolation bool

+ MaxNodes int

+ Memory int64

+ MinNodes int

+ Network int64

+ Region string

+ Zone string

+ type TaskScheduler struct

+ func NewTaskScheduler(config SchedulerConfig, coordinator *WorkerCoordinator, logger Logger) *TaskScheduler

+ func (ts *TaskScheduler) ScheduleTask(task Task) error

+ func (ts *TaskScheduler) Start() error

+ func (ts *TaskScheduler) Stop() error

+ type TaskStatus string

+ const TaskStatusCancelled

+ const TaskStatusCompleted

+ const TaskStatusFailed

+ const TaskStatusPending

+ const TaskStatusRetrying

+ const TaskStatusRunning

+ const TaskStatusScheduled

+ type ThresholdOperator string

+ const OperatorEqual

+ const OperatorGreaterEqual

+ const OperatorGreaterThan

+ const OperatorLessEqual

+ const OperatorLessThan

+ const OperatorNotEqual

+ type Toleration struct

+ Effect string

+ Key string

+ Operator string

+ Value string

+ type TraceProfiler struct

+ func (tp *TraceProfiler) Collect() (*ProfileData, error)

+ func (tp *TraceProfiler) GetName() string

+ func (tp *TraceProfiler) IsEnabled() bool

+ func (tp *TraceProfiler) Start() error

+ func (tp *TraceProfiler) Stop() error

+ type Trend struct

+ Confidence float64

+ DataPoints []DataPoint

+ Direction TrendDirection

+ Magnitude float64

+ type TrendAnalysis struct

+ CPUTrend *Trend

+ LastUpdated time.Time

+ LatencyTrend *Trend

+ MemoryTrend *Trend

+ ThroughputTrend *Trend

type TrendDirection

+ const TrendDegrading

+ const TrendImproving

+ const TrendStable

+ type VoteRecord struct

+ type WarmerMetrics struct

+ AverageWarmTime time.Duration

+ CacheHitIncrease float64

+ JobsCompleted int64

+ JobsFailed int64

+ WarmingJobs int64

+ type WarmingExecutor struct

+ type WarmingJob struct

+ Created time.Time

+ Key string

+ Priority int

+ Strategy string

+ type WarmingScheduler struct

+ type WarmingStrategy interface

+ GetPriority func(key string, entry *CacheEntry) int

+ GetWarmingData func(key string) (interface{}, error)

+ ShouldWarm func(key string, entry *CacheEntry) bool

+ type WarmingWorker struct

+ type WeightAlgorithm string

+ const WeightAdaptive

+ const WeightDynamic

+ const WeightMLBased

+ const WeightStatic

+ type WeightConfig struct

+ Algorithm WeightAlgorithm

+ ErrorRateFactor float64

+ LoadFactor float64

+ ResponseTimeFactor float64

+ UpdateInterval time.Duration

+ type WorkerCoordinator struct

+ func NewWorkerCoordinator(config CoordinatorConfig, logger Logger) *WorkerCoordinator

+ func (wc *WorkerCoordinator) Start() error

+ func (wc *WorkerCoordinator) Stop() error

+ type WorkerMetrics struct

+ AverageLatency time.Duration

+ LastTaskTime time.Time

+ Load float64

+ Status WorkerStatus

+ TasksFailed int64

+ TasksProcessed int64

+ WorkerID string

type WorkerPool

+ func (wp *WorkerPool) AddWorker() error

+ func (wp *WorkerPool) RemoveWorker() error

+ type WorkerStatus string

+ const WorkerStatusError

+ const WorkerStatusIdle

+ const WorkerStatusProcessing

+ const WorkerStatusStopped

v0.2.0-stable

Jun 20, 2025

v0.1.1

Jun 20, 2025

v0.1.0

Jun 20, 2025

Changes in this version

+ type AdaptiveController struct

+ func NewAdaptiveController(config ControllerConfig, logger Logger) *AdaptiveController

+ func (ac *AdaptiveController) ApplyAdjustment(adjustment *ParameterAdjustment) error

+ func (ac *AdaptiveController) GenerateAdjustments(recommendations []*OptimizationRecommendation) []*ParameterAdjustment

+ func (ac *AdaptiveController) GetMetrics() *ControllerMetrics

+ func (ac *AdaptiveController) Start() error

+ func (ac *AdaptiveController) Stop()

+ func (ac *AdaptiveController) ValidateAdjustment(adjustment *ParameterAdjustment) bool

+ type AdaptiveParameter struct

+ CurrentValue float64

+ History []ParameterChange

+ LastUpdate time.Time

+ MaxChangeRate float64

+ MaxValue float64

+ MinChangeThreshold float64

+ MinValue float64

+ Name string

+ func NewAdaptiveParameter(name string, current, min, max, maxChangeRate float64) *AdaptiveParameter

+ func (ap *AdaptiveParameter) GetRecentTrend() TrendDirection

+ func (ap *AdaptiveParameter) RecordChange(oldValue, newValue float64)

+ type AdaptivePredictor struct

+ type AdaptiveProfiler struct

+ type AdaptiveTuner interface

+ GetParameter func(name string) (interface{}, error)

+ GetRecommendations func() ([]TuningRecommendation, error)

+ Health func() error

+ LoadModel func(path string) error

+ RecordOutcome func(parameters map[string]interface{}, performance float64) error

+ ResetModel func() error

+ ResetParameter func(name string) error

+ SaveModel func(path string) error

+ Start func(ctx context.Context) error

+ Stop func() error

+ TuneParameter func(name string, value interface{}) error

+ type AdaptiveTunerConfig struct

+ Controller ControllerConfig

+ Feedback FeedbackConfig

+ ImpactMeasurementDelay time.Duration

+ Knowledge KnowledgeConfig

+ LearningInterval time.Duration

+ MachineLearning MLConfig

+ Optimizer OptimizerConfig

+ Predictor PredictorConfig

+ Profiler ProfilerConfig

+ TuningInterval time.Duration

+ type AdaptiveTunerImpl struct

+ func NewAdaptiveTuner(config AdaptiveTunerConfig, logger Logger) *AdaptiveTunerImpl

+ func (at *AdaptiveTunerImpl) GetAdaptationReport() *AdaptationReport

+ func (at *AdaptiveTunerImpl) GetLearningInsights() *LearningInsights

+ func (at *AdaptiveTunerImpl) GetMetrics() *AdaptiveTunerMetrics

+ func (at *AdaptiveTunerImpl) GetStats() *AdaptiveTunerStats

+ func (at *AdaptiveTunerImpl) Start() error

+ func (at *AdaptiveTunerImpl) Stop() error

+ type AdaptiveTuningConfig struct

+ type AdjustmentDirection int

+ const Decrease

+ const Increase

+ const Set

+ type Alert struct

+ CreatedAt time.Time

+ ID string

+ Message string

+ Metric string

+ Rule string

+ Severity string

+ Status string

+ Tags map[string]string

+ Threshold float64

+ UpdatedAt time.Time

+ Value float64

+ type AlertRule struct

+ Actions []string

+ Duration time.Duration

+ Metric string

+ Name string

+ Operator string

+ Severity string

+ Threshold float64

+ type AlertingConfig struct

+ Channels []NotificationChannel

+ Enabled bool

+ Rules []AlertRule

+ type AutoScaler struct

+ func NewAutoScaler(config AutoScalerConfig, logger Logger) *AutoScaler

+ func (as *AutoScaler) GetMetrics() *AutoScalerMetrics

+ func (as *AutoScaler) Start() error

+ func (as *AutoScaler) Stop()

+ func (as *AutoScaler) TriggerScaleDown(reason string) error

+ func (as *AutoScaler) TriggerScaleUp(reason string) error

+ type Buffer struct

+ Data []byte

+ Size int

+ func (b *Buffer) Close() error

+ func (b *Buffer) ID() string

+ type BufferPool struct

+ func NewBufferPool(config BufferPoolConfig) *BufferPool

+ func (p *BufferPool) Acquire(ctx context.Context) (Resource, error)

+ func (p *BufferPool) Close() error

+ func (p *BufferPool) GetStats() PoolStats

+ func (p *BufferPool) Release(resource Resource) error

+ func (p *BufferPool) Resize(newSize int) error

+ type CPUConfig struct

+ AffinityMask string

+ MaxCores int

+ Priority int

+ SchedulingPolicy string

+ type CPUOptimizationAlgorithm struct

+ func (cpua *CPUOptimizationAlgorithm) Configure(config map[string]interface{}) error

+ func (cpua *CPUOptimizationAlgorithm) GetName() string

+ func (cpua *CPUOptimizationAlgorithm) IsApplicable(context OptimizationContext) bool

+ func (cpua *CPUOptimizationAlgorithm) Optimize(context OptimizationContext) (*OptimizationResult, error)

+ type CacheConfig struct

+ Compression bool

+ Enabled bool

+ Levels []CacheLevel

+ MaxSize int64

+ Persistence bool

+ Sharding ShardingConfig

+ Strategy CacheStrategy

+ TTL time.Duration

+ type CacheEntry struct

+ AccessedAt time.Time

+ CreatedAt time.Time

+ ExpiresAt time.Time

+ Size int64

+ Value interface{}

+ type CacheLevel struct

+ Compression bool

+ MaxSize int64

+ Name string

+ Persistence bool

+ Strategy CacheStrategy

+ TTL time.Duration

+ type CacheLevelImpl struct

+ func (cl *CacheLevelImpl) Clear()

+ func (cl *CacheLevelImpl) Delete(key string)

+ func (cl *CacheLevelImpl) Get(key string) (interface{}, bool)

+ func (cl *CacheLevelImpl) Set(key string, value interface{}, ttl time.Duration) error

+ type CacheManager interface

+ ApplyOptimization func(action OptimizationAction) error

+ Clear func(ctx context.Context) error

+ Delete func(ctx context.Context, key string) error

+ DeleteMulti func(ctx context.Context, keys []string) error

+ Get func(ctx context.Context, key string) (interface{}, bool)

+ GetConfig func() CacheConfig

+ GetMetrics func() CacheMetrics

+ GetMulti func(ctx context.Context, keys []string) (map[string]interface{}, error)

+ GetStats func() CacheStats

+ Health func() error

+ Set func(ctx context.Context, key string, value interface{}, ttl time.Duration) error

+ SetMulti func(ctx context.Context, items map[string]interface{}, ttl time.Duration) error

+ Start func(ctx context.Context) error

+ Stop func() error

+ UpdateConfig func(config CacheConfig) error

+ func NewCacheManager(config CacheConfig, logger Logger) CacheManager

+ type CacheManagerImpl struct

+ func (cm *CacheManagerImpl) ApplyOptimization(action OptimizationAction) error

+ func (cm *CacheManagerImpl) Clear(ctx context.Context) error

+ func (cm *CacheManagerImpl) Delete(ctx context.Context, key string) error

+ func (cm *CacheManagerImpl) DeleteMulti(ctx context.Context, keys []string) error

+ func (cm *CacheManagerImpl) Get(ctx context.Context, key string) (interface{}, bool)

+ func (cm *CacheManagerImpl) GetConfig() CacheConfig

+ func (cm *CacheManagerImpl) GetMetrics() CacheMetrics

+ func (cm *CacheManagerImpl) GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error)

+ func (cm *CacheManagerImpl) GetStats() CacheStats

+ func (cm *CacheManagerImpl) Health() error

+ func (cm *CacheManagerImpl) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error

+ func (cm *CacheManagerImpl) SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error

+ func (cm *CacheManagerImpl) Start(ctx context.Context) error

+ func (cm *CacheManagerImpl) Stop() error

+ func (cm *CacheManagerImpl) UpdateConfig(config CacheConfig) error

+ type CacheMetrics struct

+ Evictions int64

+ HitRate float64

+ Size int64

+ type CacheOptimizationAlgorithm struct

+ func (coa *CacheOptimizationAlgorithm) Configure(config map[string]interface{}) error

+ func (coa *CacheOptimizationAlgorithm) GetName() string

+ func (coa *CacheOptimizationAlgorithm) IsApplicable(context OptimizationContext) bool

+ func (coa *CacheOptimizationAlgorithm) Optimize(context OptimizationContext) (*OptimizationResult, error)

+ type CacheStats struct

+ Evictions int64

+ HitRate float64

+ Hits int64

+ MaxSize int64

+ MemoryUsage int64

+ Misses int64

+ Size int64

+ type CacheStrategy string

+ const CacheStrategyAdaptive

+ const CacheStrategyFIFO

+ const CacheStrategyLFU

+ const CacheStrategyLRU

+ type CollectorConfig struct

+ Config map[string]interface{}

+ Enabled bool

+ Name string

+ Type string

+ type ConcurrencyConfig struct

+ MaxWorkers int

+ QueueSize int

+ Strategies []ConcurrencyStrategy

+ Throttling ThrottlingConfig

+ WorkerPools map[string]WorkerPoolConfig

+ type ConcurrencyEngine interface

+ ApplyOptimization func(action OptimizationAction) error

+ CreatePipeline func(name string, stages []PipelineStage) error

+ ExecutePipeline func(ctx context.Context, pipelineName string, input interface{}) error

+ GetConfig func() ConcurrencyConfig

+ GetMetrics func() ConcurrencyMetrics

+ GetQueueStats func() QueueStats

+ GetWorkerPools func() map[string]WorkerPoolInfo

+ Health func() error

+ ScaleWorkers func(poolName string, count int) error

+ Start func(ctx context.Context) error

+ Stop func() error

+ Submit func(ctx context.Context, task Task) error

+ SubmitBatch func(ctx context.Context, tasks []Task) error

+ SubmitWithPriority func(ctx context.Context, task Task, priority int) error

+ UpdateConfig func(config ConcurrencyConfig) error

+ type ConcurrencyEngineImpl struct

+ func NewConcurrencyEngine(config ConcurrencyConfig, logger Logger) *ConcurrencyEngineImpl

+ func (e *ConcurrencyEngineImpl) CreatePipeline(config PipelineConfig) (*Pipeline, error)

+ func (e *ConcurrencyEngineImpl) CreateWorkerPool(config WorkerPoolConfig) (*WorkerPool, error)

+ func (e *ConcurrencyEngineImpl) ExecuteBatch(tasks []Task, config BatchConfig) (*BatchResult, error)

+ func (e *ConcurrencyEngineImpl) GetMetrics() *ConcurrencyMetrics

+ func (e *ConcurrencyEngineImpl) GetStats() *ConcurrencyStats

+ func (e *ConcurrencyEngineImpl) OptimizeForSystem()

+ func (e *ConcurrencyEngineImpl) ProcessStream(stream <-chan Task, config StreamConfig) (<-chan TaskResult, error)

+ func (e *ConcurrencyEngineImpl) Start() error

+ func (e *ConcurrencyEngineImpl) Stop() error

+ func (e *ConcurrencyEngineImpl) SubmitTask(task Task) error

+ type ConcurrencyMetrics struct

+ ActiveWorkers int

+ CompletedTasks int64

+ FailedTasks int64

+ QueuedTasks int

+ type ConcurrencyStrategy struct

+ Conditions []string

+ Name string

+ Parameters map[string]interface{}

+ Type ConcurrencyType

+ type ConcurrencyType string

+ const ConcurrencyTypeFanIn

+ const ConcurrencyTypeFanOut

+ const ConcurrencyTypePipeline

+ const ConcurrencyTypeProducer

+ const ConcurrencyTypeWorkerPool

+ type Config struct

+ AdaptiveTuning AdaptiveTuningConfig

+ AutoTuning bool

+ Cache CacheConfig

+ Concurrency ConcurrencyConfig

+ Enabled bool

+ LoadBalancing LoadBalancingConfig

+ Monitoring MonitoringConfig

+ Optimization OptimizationConfig

+ ProfileName string

+ Resources ResourceConfig

+ type Connection interface

+ IsValid func() bool

+ LastUsed func() time.Time

+ type ConnectionPool struct

+ func NewConnectionPool(config ConnectionPoolConfig, logger Logger) *ConnectionPool

+ func (p *ConnectionPool) Acquire(ctx context.Context) (Resource, error)

+ func (p *ConnectionPool) Close() error

+ func (p *ConnectionPool) GetStats() PoolStats

+ func (p *ConnectionPool) Release(resource Resource) error

+ func (p *ConnectionPool) Resize(newSize int) error

+ type ConsistentHashAlgorithm struct

+ func (ch *ConsistentHashAlgorithm) Configure(config map[string]interface{}) error

+ func (ch *ConsistentHashAlgorithm) GetName() string

+ func (ch *ConsistentHashAlgorithm) SelectNode(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)

+ type ExecutionTracer struct

+ type FeedbackLoop struct

+ type FileHandlePool struct

+ type GCTuner struct

+ func NewGCTuner(config MemoryConfig) *GCTuner

+ func (gt *GCTuner) ForceGC()

+ func (gt *GCTuner) TuneGC()

+ type GeneticOptimizationAlgorithm struct

+ func (goa *GeneticOptimizationAlgorithm) Configure(config map[string]interface{}) error

+ func (goa *GeneticOptimizationAlgorithm) GetName() string

+ func (goa *GeneticOptimizationAlgorithm) IsApplicable(context OptimizationContext) bool

+ func (goa *GeneticOptimizationAlgorithm) Optimize(context OptimizationContext) (*OptimizationResult, error)

+ type HealthCheckConfig struct

+ Endpoint string

+ HealthyThreshold int

+ Interval time.Duration

+ Retries int

+ Timeout time.Duration

+ Type string

+ UnhealthyThreshold int

+ type IOConfig struct

+ type Individual struct

+ Fitness float64

+ Genes map[string]float64

+ type LargeMemoryBlock struct

+ Data []byte

+ Size int

+ func (l *LargeMemoryBlock) Close() error

+ func (l *LargeMemoryBlock) ID() string

+ type LeastConnectionsAlgorithm struct

+ func (lc *LeastConnectionsAlgorithm) Configure(config map[string]interface{}) error

+ func (lc *LeastConnectionsAlgorithm) GetName() string

+ func (lc *LeastConnectionsAlgorithm) SelectNode(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)

+ type LoadAnalyzer struct

+ type LoadBalanceAlgorithm string

+ const LoadBalanceAdaptive

+ const LoadBalanceIPHash

+ const LoadBalanceLeastConn

+ const LoadBalanceRoundRobin

+ const LoadBalanceWeighted

+ type LoadBalanceTarget struct

+ Address string

+ Enabled bool

+ ID string

+ Metadata map[string]interface{}

+ Weight int

+ type LoadBalancerImpl struct

+ func NewLoadBalancer(config LoadBalancerConfig, logger Logger) *LoadBalancerImpl

+ func (lb *LoadBalancerImpl) AddNode(config NodeConfig) error

+ func (lb *LoadBalancerImpl) BalanceRequest(request *Request) (*LoadBalancerNode, error)

+ func (lb *LoadBalancerImpl) GetLoadReport() *LoadBalancerReport

+ func (lb *LoadBalancerImpl) GetMetrics() *LoadBalancerMetrics

+ func (lb *LoadBalancerImpl) GetNodeDistribution() map[string]float64

+ func (lb *LoadBalancerImpl) GetStats() *LoadBalancerStats

+ func (lb *LoadBalancerImpl) RemoveNode(nodeID string) error

+ func (lb *LoadBalancerImpl) Start() error

+ func (lb *LoadBalancerImpl) Stop() error

+ type LoadBalancerNode struct

+ type LoadBalancingAlgorithm interface

+ Configure func(config map[string]interface{}) error

+ GetName func() string

+ SelectNode func(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)

+ type LoadBalancingConfig struct

+ type LoadPredictor struct

+ type Logger interface

+ Debug func(msg string, keysAndValues ...interface{})

+ Error func(msg string, keysAndValues ...interface{})

+ Info func(msg string, keysAndValues ...interface{})

+ Warn func(msg string, keysAndValues ...interface{})

+ type MLConfig struct

+ Evaluation EvaluationConfig

+ Features FeatureConfig

+ MinTrainingSamples int

+ Pipeline PipelineConfig

+ Training TrainingConfig

+ TrainingInterval time.Duration

+ type MLModelType int

+ const LinearRegression

+ const NeuralNetwork

+ const RandomForest

+ const SVM

+ type MachineLearner struct

+ func NewMachineLearner(config MLConfig, logger Logger) *MachineLearner

+ func (ml *MachineLearner) EvaluateModels() *ModelEvaluation

+ func (ml *MachineLearner) ExtractFeatures() *FeatureSet

+ func (ml *MachineLearner) ExtractPatterns() []*PerformancePattern

+ func (ml *MachineLearner) GetMetrics() *MLMetrics

+ func (ml *MachineLearner) Start() error

+ func (ml *MachineLearner) Stop()

+ func (ml *MachineLearner) TrainModels(features *FeatureSet)

+ func (ml *MachineLearner) UpdateModels()

+ type MemoryBlock struct

+ Data []byte

+ Size int

+ func (m *MemoryBlock) Close() error

+ func (m *MemoryBlock) ID() string

+ type MemoryConfig struct

+ EnableProfiling bool

+ GCTarget int

+ GCThreshold float64

+ MaxHeapSize int64

+ PoolSizes map[string]int

+ type MemoryManager struct

+ func NewMemoryManager(config MemoryConfig, logger Logger) *MemoryManager

+ func (mm *MemoryManager) CreatePool(name string, factory func() interface{}, reset func(interface{}), maxSize int)

+ func (mm *MemoryManager) GetPool(name string) *ObjectPool

+ func (mm *MemoryManager) OptimizeMemory()

+ type MemoryOptimizationAlgorithm struct

+ func (moa *MemoryOptimizationAlgorithm) Configure(config map[string]interface{}) error

+ func (moa *MemoryOptimizationAlgorithm) GetName() string

+ func (moa *MemoryOptimizationAlgorithm) IsApplicable(context OptimizationContext) bool

+ func (moa *MemoryOptimizationAlgorithm) Optimize(context OptimizationContext) (*OptimizationResult, error)

+ type MemoryPool struct

+ func NewMemoryPool(config MemoryPoolConfig) *MemoryPool

+ func (p *MemoryPool) Acquire(ctx context.Context) (Resource, error)

+ func (p *MemoryPool) Close() error

+ func (p *MemoryPool) GetStats() PoolStats

+ func (p *MemoryPool) Release(resource Resource) error

+ func (p *MemoryPool) Resize(newSize int) error

+ type MemoryProfiler struct

+ func NewMemoryProfiler(enabled bool) *MemoryProfiler

+ func (mp *MemoryProfiler) GetSnapshots() []*MemorySnapshot

+ func (mp *MemoryProfiler) TakeSnapshot()

+ type MemorySnapshot struct

+ Allocations int64

+ GCRuns int64

+ HeapSize int64

+ HeapUsed int64

+ Objects int64

+ Timestamp time.Time

+ type Metric struct

+ Name string

+ Tags map[string]string

+ Timestamp time.Time

+ Type string

+ Value float64

+ type MetricQuery struct

+ Aggregation string

+ EndTime time.Time

+ Metric string

+ StartTime time.Time

+ Tags map[string]string

+ type MetricResult struct

+ Metrics []Metric

+ Summary MetricSummary

+ type MetricSummary struct

+ Average float64

+ Count int64

+ Max float64

+ Min float64

+ Sum float64

+ type MetricsCollector struct

+ func NewMetricsCollector(config CollectorConfig, logger Logger) *MetricsCollector

+ func (c *MetricsCollector) GetMetrics() *CollectorMetrics

+ func (c *MetricsCollector) Start() error

+ func (c *MetricsCollector) Stop()

+ type MonitorMetrics struct

+ type MonitoringConfig struct

+ type MonitoringDashboard struct

+ type NetworkBuffers struct

+ Read int

+ Write int

+ type NetworkConfig struct

+ type NotificationChannel struct

+ Config map[string]interface{}

+ Enabled bool

+ Name string

+ Type string

+ type ObjectPool struct

+ func (op *ObjectPool) Get() interface{}

+ func (op *ObjectPool) IsIdle() bool

+ func (op *ObjectPool) Put(obj interface{})

+ type OptimizationAction struct

+ type OptimizationAlgorithm interface

+ Configure func(config map[string]interface{}) error

+ GetName func() string

+ IsApplicable func(context OptimizationContext) bool

+ Optimize func(context OptimizationContext) (*OptimizationResult, error)

+ type OptimizationAnalyzer struct

+ func NewOptimizationAnalyzer(config AnalyzerConfig, logger Logger) *OptimizationAnalyzer

+ func (oa *OptimizationAnalyzer) AnalyzeOpportunities() []*OptimizationOpportunity

+ func (oa *OptimizationAnalyzer) GetMetrics() *AnalyzerMetrics

+ func (oa *OptimizationAnalyzer) Start() error

+ func (oa *OptimizationAnalyzer) Stop()

+ type OptimizationCondition struct

+ type OptimizationConfig struct

+ type OptimizationConstraint struct

+ Hard bool

+ Metric string

+ Operator string

+ Value float64

+ type OptimizationEngine interface

+ EvaluateSolution func(solution OptimizationSolution) (float64, error)

+ GetAlgorithms func() []OptimizationAlgorithm

+ GetBestSolution func() (*OptimizationSolution, error)

+ GetSolutionHistory func() ([]OptimizationSolution, error)

+ Health func() error

+ Optimize func(ctx context.Context, objectives []OptimizationObjective) (*OptimizationResult, error)

+ RegisterAlgorithm func(algorithm OptimizationAlgorithm) error

+ Start func(ctx context.Context) error

+ Stop func() error

+ type OptimizationEngineImpl struct

+ func NewOptimizationEngine(config OptimizationConfig, logger Logger) *OptimizationEngineImpl

+ func (oe *OptimizationEngineImpl) GetMetrics() *OptimizationMetrics

+ func (oe *OptimizationEngineImpl) GetStats() *OptimizationStats

+ func (oe *OptimizationEngineImpl) RegisterAlgorithm(name string, algorithm OptimizationAlgorithm)

+ func (oe *OptimizationEngineImpl) Start() error

+ func (oe *OptimizationEngineImpl) Stop() error

+ type OptimizationExecutor struct

+ type OptimizationObjective struct

+ Direction string

+ Metric string

+ Target float64

+ Weight float64

+ type OptimizationRecommendation struct

+ Action string

+ Description string

+ Priority Priority

+ Type OptimizationType

+ type OptimizationResult struct

+ Convergent bool

+ Duration time.Duration

+ Iterations int

+ Metadata map[string]interface{}

+ Score float64

+ Solution OptimizationSolution

+ type OptimizationRule struct

+ Action OptimizationAction

+ Condition OptimizationCondition

+ Enabled bool

+ ID string

+ Name string

+ Priority int

+ Type OptimizationType

+ type OptimizationScheduler struct

+ type OptimizationSolution struct

+ AppliedAt *time.Time

+ CreatedAt time.Time

+ ID string

+ Parameters map[string]interface{}

+ Score float64

+ type OptimizationType string

+ const OptimizationTypeAlgorithm

+ const OptimizationTypeCache

+ const OptimizationTypeConcurrency

+ const OptimizationTypeIO

+ const OptimizationTypeMemory

+ const OptimizationTypeNetwork

+ type PerformanceAlerter struct

+ type PerformanceAnalyzer struct

+ func NewPerformanceAnalyzer(config AnalyzerConfig, logger Logger) *PerformanceAnalyzer

+ func (a *PerformanceAnalyzer) Analyze()

+ func (a *PerformanceAnalyzer) GetMetrics() *AnalyzerMetrics

+ func (a *PerformanceAnalyzer) Start() error

+ func (a *PerformanceAnalyzer) Stop()

+ type PerformanceConstraints struct

+ MaxCacheSize int64

+ MaxConnections int

+ MaxMemory int64

+ MaxWorkers int

+ type PerformanceManager struct

+ func NewPerformanceManager(config *Config, logger Logger) *PerformanceManager

+ func (pm *PerformanceManager) ApplyProfile(profileName string) error

+ func (pm *PerformanceManager) DisableAutoTuning() error

+ func (pm *PerformanceManager) EnableAutoTuning() error

+ func (pm *PerformanceManager) GetMetrics() *PerformanceMetrics

+ func (pm *PerformanceManager) GetProfile(name string) (*PerformanceProfile, error)

+ func (pm *PerformanceManager) GetRecommendations() []OptimizationRecommendation

+ func (pm *PerformanceManager) OptimizeFor(target PerformanceTarget) error

+ func (pm *PerformanceManager) Shutdown(timeout time.Duration) error

+ type PerformanceMetrics struct

+ ActiveWorkers int

+ CPUUsage float64

+ CacheEvictions int64

+ CacheHitRate float64

+ CacheSize int64

+ CompletedTasks int64

+ ErrorRate float64

+ FailedTasks int64

+ GCStats runtime.GCStats

+ GoroutineCount int

+ LastUpdate time.Time

+ LatencyP50 time.Duration

+ LatencyP95 time.Duration

+ LatencyP99 time.Duration

+ MemoryUsage int64

+ PoolUtilization map[string]float64

+ QueuedTasks int

+ ResourceWaits map[string]time.Duration

+ StartTime time.Time

+ ThroughputRPS float64

+ type PerformanceMonitor interface

+ AddAlertRule func(rule AlertRule) error

+ GetActiveAlerts func() ([]Alert, error)

+ GetMetric func(name string) (*Metric, error)

+ GetMetrics func(pattern string) ([]*Metric, error)

+ Health func() error

+ QueryMetrics func(query MetricQuery) (*MetricResult, error)

+ RecordCounter func(name string, value int64, tags map[string]string) error

+ RecordLatency func(name string, duration time.Duration, tags map[string]string) error

+ RecordMetric func(name string, value float64, tags map[string]string) error

+ RemoveAlertRule func(name string) error

+ Start func(ctx context.Context) error

+ Stop func() error

+ type PerformanceMonitorImpl struct

+ func NewPerformanceMonitor(config MonitoringConfig, logger Logger) *PerformanceMonitorImpl

+ func (m *PerformanceMonitorImpl) CreateAnalyzer(config AnalyzerConfig) (*PerformanceAnalyzer, error)

+ func (m *PerformanceMonitorImpl) CreateCollector(config CollectorConfig) (*MetricsCollector, error)

+ func (m *PerformanceMonitorImpl) ExportMetrics(format string) ([]byte, error)

+ func (m *PerformanceMonitorImpl) GetCurrentMetrics() map[string]interface{}

+ func (m *PerformanceMonitorImpl) GetMetrics() *MonitoringMetrics

+ func (m *PerformanceMonitorImpl) GetPerformanceReport() *PerformanceReport

+ func (m *PerformanceMonitorImpl) GetStats() *MonitoringStats

+ func (m *PerformanceMonitorImpl) GetTopMetrics(limit int) []*MetricSummary

+ func (m *PerformanceMonitorImpl) RecordMetric(name string, value float64, tags map[string]string)

+ func (m *PerformanceMonitorImpl) Start() error

+ func (m *PerformanceMonitorImpl) StartTrace(name string) *TraceSpan

+ func (m *PerformanceMonitorImpl) Stop() error

+ type PerformanceProfile struct

+ Constraints PerformanceConstraints

+ CreatedAt time.Time

+ Description string

+ Name string

+ Optimizations []OptimizationRule

+ Target PerformanceTarget

+ UpdatedAt time.Time

+ type PerformanceTarget struct

+ MaxCPUUsage float64

+ MaxErrorRate float64

+ MaxLatency time.Duration

+ MaxMemoryUsage int64

+ MinThroughput float64

+ type Pipeline struct

+ func NewPipeline(config PipelineConfig, logger Logger) *Pipeline

+ func (p *Pipeline) GetMetrics() *PipelineMetrics

+ func (p *Pipeline) GetOutput() <-chan PipelineOutput

+ func (p *Pipeline) Start() error

+ func (p *Pipeline) Stop()

+ func (p *Pipeline) Submit(input PipelineInput) error

+ type PipelineStage struct

+ func NewPipelineStage(config StageConfig, pipeline *Pipeline, inputCh chan StageInput, ...) *PipelineStage

+ func (s *PipelineStage) GetMetrics() *StageMetrics

+ func (s *PipelineStage) Run()

+ type PipelineStageConfig struct

+ Function func(ctx context.Context, input interface{}) (interface{}, error)

+ Name string

+ Parallel bool

+ Timeout time.Duration

+ type PoolInfo struct

+ Available int

+ Created int64

+ Destroyed int64

+ InUse int

+ LastActivity time.Time

+ Name string

+ Size int

+ Type ResourceType

+ type PoolStats struct

+ AcquisitionTime time.Duration

+ ErrorRate float64

+ UtilizationRate float64

+ WaitingCount int

+ type PooledAllocator struct

+ func NewPooledAllocator() *PooledAllocator

+ func (pa *PooledAllocator) GetBuffer(size int) []byte

+ func (pa *PooledAllocator) PutBuffer(buffer []byte)

+ type Priority string

+ const PriorityHigh

+ const PriorityLow

+ const PriorityMedium

+ type ProcessingNode struct

+ type QueueStats struct

+ AverageWaitTime time.Duration

+ QueueSizes map[string]int

+ TotalProcessed int64

+ TotalQueued int64

+ type RandomAlgorithm struct

+ func (ra *RandomAlgorithm) Configure(config map[string]interface{}) error

+ func (ra *RandomAlgorithm) GetName() string

+ func (ra *RandomAlgorithm) SelectNode(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)

+ type RequestRouter struct

+ type Resource interface

+ Close func() error

+ ID func() string

+ type ResourceAllocator struct

+ type ResourceConfig struct

+ CPU CPUConfig

+ IO IOConfig

+ Memory MemoryConfig

+ Network NetworkConfig

+ Pools []ResourcePoolConfig

+ type ResourceMetrics struct

+ Utilization map[string]float64

+ WaitTimes map[string]time.Duration

+ type ResourceMonitor struct

+ type ResourcePool interface

+ Acquire func(ctx context.Context) (Resource, error)

+ Close func() error

+ GetStats func() PoolStats

+ Release func(resource Resource) error

+ Resize func(newSize int) error

+ type ResourcePoolConfig struct

+ type ResourcePoolManager interface

+ Acquire func(ctx context.Context, poolName string) (Resource, error)

+ CreatePool func(name string, config ResourcePoolConfig) error

+ DeletePool func(name string) error

+ GetMetrics func() ResourceMetrics

+ GetPool func(name string) (ResourcePool, error)

+ GetPoolInfo func(poolName string) (PoolInfo, error)

+ Health func() error

+ ListPools func() []PoolInfo

+ Release func(poolName string, resource Resource) error

+ Start func(ctx context.Context) error

+ Stop func() error

+ type ResourcePoolManagerImpl struct

+ func NewResourcePoolManager(config ResourcePoolConfig, logger Logger) *ResourcePoolManagerImpl

+ func (m *ResourcePoolManagerImpl) CreateBufferPool(config BufferPoolConfig) (ResourcePool, error)

+ func (m *ResourcePoolManagerImpl) CreateConnectionPool(config ConnectionPoolConfig) (ResourcePool, error)

+ func (m *ResourcePoolManagerImpl) CreateMemoryPool(config MemoryPoolConfig) (ResourcePool, error)

+ func (m *ResourcePoolManagerImpl) GetMetrics() *ResourceMetrics

+ func (m *ResourcePoolManagerImpl) GetPool(id string) (ResourcePool, error)

+ func (m *ResourcePoolManagerImpl) GetStats() *ResourceStats

+ func (m *ResourcePoolManagerImpl) OptimizeForSystem()

+ func (m *ResourcePoolManagerImpl) Start() error

+ func (m *ResourcePoolManagerImpl) Stop() error

+ type ResourceRecycler struct

+ type ResourceType string

+ const ResourceTypeBuffer

+ const ResourceTypeConnection

+ const ResourceTypeMemory

+ const ResourceTypeThread

+ type RoundRobinAlgorithm struct

+ func (rr *RoundRobinAlgorithm) Configure(config map[string]interface{}) error

+ func (rr *RoundRobinAlgorithm) GetName() string

+ func (rr *RoundRobinAlgorithm) SelectNode(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)

+ type Scheduler struct

+ func NewScheduler(config SchedulerConfig, logger Logger) *Scheduler

+ func (s *Scheduler) GetMetrics() *SchedulerMetrics

+ func (s *Scheduler) Start() error

+ func (s *Scheduler) Stop()

+ func (s *Scheduler) SubmitTask(task Task) error

+ type ShardingConfig struct

+ Algorithm string

+ Enabled bool

+ KeyExtractor string

+ ShardCount int

+ type SimulatedAnnealingAlgorithm struct

+ func (saa *SimulatedAnnealingAlgorithm) Configure(config map[string]interface{}) error

+ func (saa *SimulatedAnnealingAlgorithm) GetName() string

+ func (saa *SimulatedAnnealingAlgorithm) IsApplicable(context OptimizationContext) bool

+ func (saa *SimulatedAnnealingAlgorithm) Optimize(context OptimizationContext) (*OptimizationResult, error)

+ type SlicePool struct

+ type Solution struct

+ Parameters map[string]float64

+ func (s *Solution) Copy() *Solution

+ type SystemProfiler struct

+ func NewSystemProfiler(config ProfilerConfig, logger Logger) *SystemProfiler

+ func (p *SystemProfiler) GetMetrics() *ProfilerMetrics

+ func (p *SystemProfiler) GetProfile() *SystemProfile

+ func (p *SystemProfiler) Start() error

+ func (p *SystemProfiler) Stop()

+ type Task interface

+ Execute func(ctx context.Context) error

+ GetID func() string

+ GetPriority func() int

+ func NewDefaultTask(id string, fn func(context.Context) error) Task

+ type TaskExecutor struct

+ type ThreadPool struct

+ type ThrottlingConfig struct

+ Algorithm string

+ BurstSize int

+ Enabled bool

+ RateLimit float64

+ Window time.Duration

+ type TrendDirection int

+ const DecreasingTrend

+ const IncreasingTrend

+ const NoTrend

+ const StableTrend

+ func (td TrendDirection) String() string

+ type TuningParameter struct

+ Current interface{}

+ Importance float64

+ MaxValue interface{}

+ MinValue interface{}

+ Name string

+ StepSize interface{}

+ Type string

+ type TuningRecommendation struct

+ Confidence float64

+ CurrentValue interface{}

+ Impact float64

+ Parameter string

+ Reason string

+ RecommendedValue interface{}

+ type WeightedRoundRobinAlgorithm struct

+ func (wrr *WeightedRoundRobinAlgorithm) Configure(config map[string]interface{}) error

+ func (wrr *WeightedRoundRobinAlgorithm) GetName() string

+ func (wrr *WeightedRoundRobinAlgorithm) SelectNode(nodes []*LoadBalancerNode, request *Request) (*LoadBalancerNode, error)

+ type Worker struct

+ func NewWorker(id string, pool *WorkerPool, processor TaskProcessor) *Worker

+ func (w *Worker) GetMetrics() *WorkerMetrics

+ func (w *Worker) IsActive() bool

+ func (w *Worker) Run()

+ type WorkerPool struct

+ func NewWorkerPool(config WorkerPoolConfig, logger Logger) *WorkerPool

+ func (p *WorkerPool) GetActiveWorkers() int

+ func (p *WorkerPool) GetMetrics() *WorkerPoolMetrics

+ func (p *WorkerPool) Scale(delta int) error

+ func (p *WorkerPool) Start() error

+ func (p *WorkerPool) Stop()

+ func (p *WorkerPool) SubmitTask(task Task) error

+ type WorkerPoolConfig struct

+ IdleTimeout time.Duration

+ MaxWorkers int

+ MinWorkers int

+ Name string

+ QueueSize int

+ TaskTimeout time.Duration

+ type WorkerPoolInfo struct

+ ActiveWorkers int

+ CompletedTasks int64

+ FailedTasks int64

+ LastActivity time.Time

+ Name string

+ QueuedTasks int

+ type WorkloadCoordinator struct

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL