feat: measure mounted disk emas as well

Author: christyjacob4

main.go

@@ -38,7 +38,7 @@ type SystemMonitor struct {
 	// EMA tracking
 	cpuEMA         float64
 	memoryEMA      float64
-	diskEMA        float64
+	diskEMAs       map[string]float64 // Map to track EMAs for all disks (root and mounted)
 	alpha          float64 // EMA smoothing factor
 }
 
@@ -65,6 +65,7 @@ func NewSystemMonitor(betterStackURL string, interval int, cpuLimit, memoryLimit
 		diskLimit:      diskLimit,
 		interval:       interval,
 		log:            New(),
+		diskEMAs:       make(map[string]float64), // Initialize the map for all disk EMAs
 		alpha:          alpha,
 	}, nil
 }
@@ -151,20 +152,31 @@ func (s *SystemMonitor) checkMemory() error {
 
 func (s *SystemMonitor) checkDisk() error {
 	// Check root partition
-	usage, err := disk.Usage("/")
+	rootPath := "/"
+	usage, err := disk.Usage(rootPath)
 	if err != nil {
 		return fmt.Errorf("failed to get disk usage: %v", err)
 	}
 
 	instantValue := usage.UsedPercent
-	s.diskEMA = s.calculateEMA(instantValue, s.diskEMA)
 
-	status := s.getStatus(s.diskEMA, s.diskLimit)
+	// Calculate or update EMA for root disk
+	if _, exists := s.diskEMAs[rootPath]; !exists {
+		// Initialize EMA with current value if this is first check
+		s.diskEMAs[rootPath] = instantValue
+	}
+	
+	// Update EMA for root disk
+	s.diskEMAs[rootPath] = s.calculateEMA(instantValue, s.diskEMAs[rootPath])
+	
+	rootEMA := s.diskEMAs[rootPath]
+	status := s.getStatus(rootEMA, s.diskLimit)
+	
 	if status == "fail" {
-		s.log.Warn("Root disk usage EMA %.2f%% exceeds limit of %.2f%% (instant: %.2f%%)", s.diskEMA, s.diskLimit, instantValue)
+		s.log.Warn("Root disk usage EMA %.2f%% exceeds limit of %.2f%% (instant: %.2f%%)", rootEMA, s.diskLimit, instantValue)
 	} else {
 		s.log.Log("Root disk usage EMA: %.2f%% (limit: %.2f%%, instant: %.2f%%), Free: %d MB, Total: %d MB",
-			s.diskEMA,
+			rootEMA,
 			s.diskLimit,
 			instantValue,
 			usage.Free/(1024*1024),
@@ -177,7 +189,7 @@ func (s *SystemMonitor) checkDisk() error {
 		AlertID:   fmt.Sprintf("disk-root-%s", s.hostname),
 		Timestamp: time.Now().Unix(),
 		Status:    status,
-		Value:     s.diskEMA,
+		Value:     rootEMA,
 		Limit:     s.diskLimit,
 	}); err != nil {
 		return err
@@ -197,13 +209,25 @@ func (s *SystemMonitor) checkDisk() error {
 		}
 
 		instantValue := usage.UsedPercent
-		status := s.getStatus(s.diskEMA, s.diskLimit)
+		
+		// Calculate or update EMA for this mount
+		if _, exists := s.diskEMAs[mount]; !exists {
+			// Initialize EMA with current value if this is first check
+			s.diskEMAs[mount] = instantValue
+		}
+		
+		// Update EMA for this mount
+		s.diskEMAs[mount] = s.calculateEMA(instantValue, s.diskEMAs[mount])
+		
+		mountEMA := s.diskEMAs[mount]
+		status := s.getStatus(mountEMA, s.diskLimit)
+		
 		if status == "fail" {
-			s.log.Warn("Disk usage for %s EMA %.2f%% exceeds limit of %.2f%% (instant: %.2f%%)", mount, s.diskEMA, s.diskLimit, instantValue)
+			s.log.Warn("Disk usage for %s EMA %.2f%% exceeds limit of %.2f%% (instant: %.2f%%)", mount, mountEMA, s.diskLimit, instantValue)
 		} else {
 			s.log.Log("Disk usage for %s EMA: %.2f%% (limit: %.2f%%, instant: %.2f%%), Free: %d MB, Total: %d MB",
 				mount,
-				s.diskEMA,
+				mountEMA,
 				s.diskLimit,
 				instantValue,
 				usage.Free/(1024*1024),
@@ -216,7 +240,7 @@ func (s *SystemMonitor) checkDisk() error {
 			AlertID:   fmt.Sprintf("disk-%s-%s", filepath.Base(mount), s.hostname),
 			Timestamp: time.Now().Unix(),
 			Status:    status,
-			Value:     s.diskEMA,
+			Value:     mountEMA,
 			Limit:     s.diskLimit,
 		}); err != nil {
 			return err

main_test.go

@@ -141,4 +141,112 @@ func TestEMADifferentIntervals(t *testing.T) {
 			}
 		})
 	}
+}
+
+func TestDiskEMAs(t *testing.T) {
+	// Create a monitor with a 60-second interval
+	monitor, err := NewSystemMonitor("http://test.com", 60, 90.0, 90.0, 90.0)
+	if err != nil {
+		t.Fatalf("Failed to create monitor: %v", err)
+	}
+
+	// Test case 1: Verify root disk EMA updates correctly
+	t.Run("RootDiskEMA", func(t *testing.T) {
+		rootPath := "/"
+		
+		// Simulate initial usage
+		monitor.diskEMAs[rootPath] = 50.0
+		
+		// Simulate a series of measurements
+		values := []float64{60.0, 70.0, 80.0, 90.0}
+		for _, v := range values {
+			monitor.diskEMAs[rootPath] = monitor.calculateEMA(v, monitor.diskEMAs[rootPath])
+		}
+		
+		// EMA should be between 70% and 90%
+		if monitor.diskEMAs[rootPath] < 70.0 || monitor.diskEMAs[rootPath] > 90.0 {
+			t.Errorf("Expected root disk EMA to be between 70%% and 90%%, got %.2f%%", monitor.diskEMAs[rootPath])
+		}
+	})
+
+	// Test case 2: Verify multiple mount points are tracked independently
+	t.Run("MultipleMountEMAs", func(t *testing.T) {
+		// Setup test mounts with different starting values
+		mounts := map[string]float64{
+			"/mnt/data1": 30.0,
+			"/mnt/data2": 50.0,
+			"/mnt/logs":  70.0,
+		}
+		
+		// Initialize starting values
+		for path, value := range mounts {
+			monitor.diskEMAs[path] = value
+		}
+		
+		// Apply the same change to all mounts (+20%)
+		for path := range mounts {
+			currentValue := monitor.diskEMAs[path]
+			newValue := currentValue + 20.0
+			if newValue > 100.0 {
+				newValue = 100.0
+			}
+			monitor.diskEMAs[path] = monitor.calculateEMA(newValue, currentValue)
+		}
+		
+		// Verify each mount's EMA updated independently
+		for path, initialValue := range mounts {
+			expectedMinimum := initialValue
+			expectedMaximum := initialValue + 20.0 // Full change would be +20%
+			if expectedMaximum > 100.0 {
+				expectedMaximum = 100.0
+			}
+			
+			// With our alpha, the EMA should be approximately between the initial value and the initial + 7% (1/3 of 20%)
+			expectedMinimum = initialValue
+			expectedMaximum = initialValue + 7.0
+			
+			actualValue := monitor.diskEMAs[path]
+			if actualValue < expectedMinimum || actualValue > expectedMaximum {
+				t.Errorf("Mount %s: Expected EMA between %.2f%% and %.2f%%, got %.2f%%", 
+					path, expectedMinimum, expectedMaximum, actualValue)
+			}
+		}
+		
+		// Extract just the mount values we're testing
+		mountValues := make([]float64, 0, len(mounts))
+		for path := range mounts {
+			mountValues = append(mountValues, monitor.diskEMAs[path])
+		}
+		
+		// Verify mount points have different values (they're independent)
+		if len(unique(mountValues)) != len(mounts) {
+			t.Errorf("Expected all mount EMAs to be different, got: %v", mountValues)
+		}
+	})
+}
+
+// Helper functions for the disk EMA tests
+
+// Return values from a map as a slice
+func getValues(m map[string]float64) []float64 {
+	values := make([]float64, 0, len(m))
+	for _, v := range m {
+		values = append(values, v)
+	}
+	return values
+}
+
+// Return unique values from a slice
+func unique(values []float64) []float64 {
+	seen := make(map[float64]bool)
+	unique := make([]float64, 0)
+	
+	for _, v := range values {
+		if !seen[v] {
+			seen[v] = true
+			unique = append(unique, v)
+		}
+	}
+	
+	return unique
 }