Fix formating issues

Signed-off-by: AKRAM@il.ibm.com <akram@fhe3.haifa.ibm.com>

Author: AKRAM@il.ibm.com

platform/common/utils/metrics.go

@@ -42,19 +42,19 @@ func ExponentialBucketTimeRange(start, end time.Duration, buckets int) []float64
 	if buckets <= 1 {
 		return []float64{roundToSignificantDigits(start.Seconds(), 6)}
 	}
-	
+
 	interval := end - start
 	if interval <= 0 {
 		return []float64{roundToSignificantDigits(start.Seconds(), 6)}
 	}
-	
+
 	// Calculate factor more safely using Pow instead of Exp(Log(...))
 	// This ensures we generate exactly 'buckets' number of buckets
 	factor := math.Pow(float64(interval)/precision, 1.0/float64(buckets-1))
-	
+
 	bs := make([]float64, 0, buckets)
 	bs = append(bs, roundToSignificantDigits(start.Seconds(), 6))
-	
+
 	// Generate exactly buckets-1 additional buckets
 	for i := 1; i < buckets; i++ {
 		v := time.Duration(math.Pow(factor, float64(i)) * precision)
@@ -64,7 +64,7 @@ func ExponentialBucketTimeRange(start, end time.Duration, buckets int) []float64
 		// Round to 6 significant digits to avoid ugly floating-point representations
 		bs = append(bs, roundToSignificantDigits((start+v).Seconds(), 6))
 	}
-	
+
 	return bs
 }
 
@@ -74,16 +74,16 @@ func roundToSignificantDigits(value float64, sigDigits int) float64 {
 	if value == 0 {
 		return 0
 	}
-	
+
 	// Determine the order of magnitude
 	magnitude := math.Floor(math.Log10(math.Abs(value)))
-	
+
 	// Calculate the scaling factor to get sigDigits significant figures
 	scale := math.Pow(10, float64(sigDigits-1)-magnitude)
-	
+
 	// Round to significant digits
 	rounded := math.Round(value*scale) / scale
-	
+
 	// Additional cleanup: round to remove floating-point artifacts
 	// This handles cases like 0.0016681000000000001 -> 0.0016681
 	if rounded != 0 {
@@ -94,6 +94,6 @@ func roundToSignificantDigits(value float64, sigDigits int) float64 {
 			rounded = math.Round(rounded*multiplier) / multiplier
 		}
 	}
-	
+
 	return rounded
 }

platform/common/utils/metrics_test.go

@@ -17,7 +17,7 @@ import (
 func TestFix1_SaferCalculation_MaintainsExponentialSpacing(t *testing.T) {
 	t.Run("Verify exponential spacing with constant ratio", func(t *testing.T) {
 		buckets := ExponentialBucketTimeRange(0, 1*time.Second, 10)
-		
+
 		// Calculate ratios between consecutive buckets
 		var ratios []float64
 		for i := 2; i < len(buckets); i++ {
@@ -26,20 +26,20 @@ func TestFix1_SaferCalculation_MaintainsExponentialSpacing(t *testing.T) {
 				ratios = append(ratios, ratio)
 			}
 		}
-		
+
 		// All ratios should be approximately equal (exponential spacing)
 		if len(ratios) < 2 {
 			t.Fatal("Not enough ratios to verify exponential spacing")
 		}
-		
+
 		expectedRatio := ratios[0]
 		for i, ratio := range ratios {
 			diff := math.Abs(ratio - expectedRatio)
 			if diff > 0.01 { // Allow 1% tolerance
 				t.Errorf("Ratio %d: %.6f differs from expected %.6f by %.6f", i, ratio, expectedRatio, diff)
 			}
 		}
-		
+
 		t.Logf("✓ Exponential spacing confirmed: constant ratio = %.6f", expectedRatio)
 		t.Logf("  Buckets: %v", buckets)
 	})
@@ -59,11 +59,11 @@ func TestFix2_GuaranteedExactBucketCount(t *testing.T) {
 		{"2 buckets", 0, 1 * time.Second, 2},
 		{"20 buckets", 0, 10 * time.Second, 20},
 	}
-	
+
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			result := ExponentialBucketTimeRange(tc.start, tc.end, tc.buckets)
-			
+
 			if len(result) != tc.buckets {
 				t.Errorf("Expected exactly %d buckets, got %d", tc.buckets, len(result))
 				t.Errorf("Buckets: %v", result)
@@ -78,33 +78,33 @@ func TestFix2_GuaranteedExactBucketCount(t *testing.T) {
 func TestFix3_IndependentCalculation_NoErrorAccumulation(t *testing.T) {
 	t.Run("Verify monotonically increasing values", func(t *testing.T) {
 		buckets := ExponentialBucketTimeRange(0, 5*time.Second, 15)
-		
+
 		for i := 1; i < len(buckets); i++ {
 			if buckets[i] <= buckets[i-1] {
-				t.Errorf("Bucket %d (%.10f) is not greater than bucket %d (%.10f)", 
+				t.Errorf("Bucket %d (%.10f) is not greater than bucket %d (%.10f)",
 					i, buckets[i], i-1, buckets[i-1])
 			}
 		}
-		
+
 		t.Logf("✓ All buckets monotonically increasing")
 	})
-	
+
 	t.Run("Verify first and last buckets match start and end", func(t *testing.T) {
 		start := 0 * time.Second
 		end := 1 * time.Second
 		buckets := ExponentialBucketTimeRange(start, end, 10)
-		
+
 		if buckets[0] != start.Seconds() {
 			t.Errorf("First bucket %.10f != start %.10f", buckets[0], start.Seconds())
 		}
-		
+
 		// Last bucket should be close to end (within rounding)
 		diff := math.Abs(buckets[len(buckets)-1] - end.Seconds())
 		if diff > 0.01 {
-			t.Errorf("Last bucket %.10f differs from end %.10f by %.10f", 
+			t.Errorf("Last bucket %.10f differs from end %.10f by %.10f",
 				buckets[len(buckets)-1], end.Seconds(), diff)
 		}
-		
+
 		t.Logf("✓ First bucket = %.10f (start)", buckets[0])
 		t.Logf("✓ Last bucket = %.10f (end = %.10f)", buckets[len(buckets)-1], end.Seconds())
 	})
@@ -114,29 +114,29 @@ func TestFix3_IndependentCalculation_NoErrorAccumulation(t *testing.T) {
 func TestFix4_RoundingProducesCleanValues(t *testing.T) {
 	t.Run("Verify Prometheus output format is clean", func(t *testing.T) {
 		buckets := ExponentialBucketTimeRange(0, 1*time.Second, 10)
-		
+
 		for i, v := range buckets {
 			// Format as Prometheus would (%g format)
 			prometheusStr := fmt.Sprintf("%g", v)
-			
+
 			// Check for ugly patterns
 			if len(prometheusStr) > 12 && v > 0 && v < 10 {
 				t.Errorf("Bucket %d has potentially ugly Prometheus output: le=\"%s\"", i, prometheusStr)
 			}
-			
+
 			t.Logf("Bucket %d: le=\"%s\" ✓", i, prometheusStr)
 		}
 	})
-	
+
 	t.Run("Compare internal vs Prometheus representation", func(t *testing.T) {
 		buckets := ExponentialBucketTimeRange(0, 100*time.Millisecond, 10)
-		
+
 		t.Logf("\nInternal vs Prometheus representation:")
 		for i, v := range buckets {
 			internal := fmt.Sprintf("%.17g", v)
 			prometheus := fmt.Sprintf("%g", v)
 			t.Logf("  Bucket %d: internal=%.17g, prometheus=le=\"%s\"", i, v, prometheus)
-			
+
 			// Prometheus format should be shorter/cleaner
 			if len(prometheus) > len(internal) {
 				t.Errorf("Prometheus format longer than internal for bucket %d", i)
@@ -162,7 +162,7 @@ func TestFix5_EdgeCaseHandling(t *testing.T) {
 		{"Start greater than end", 5 * time.Second, 1 * time.Second, 10, 1, false},
 		{"Normal case", 0, 1 * time.Second, 10, 10, false},
 	}
-	
+
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			defer func() {
@@ -172,15 +172,15 @@ func TestFix5_EdgeCaseHandling(t *testing.T) {
 					}
 				}
 			}()
-			
+
 			result := ExponentialBucketTimeRange(tc.start, tc.end, tc.buckets)
-			
+
 			if len(result) != tc.expectedLength {
 				t.Errorf("Expected %d buckets, got %d", tc.expectedLength, len(result))
 			} else {
 				t.Logf("✓ Handled edge case correctly: got %d bucket(s)", len(result))
 			}
-			
+
 			t.Logf("  Result: %v", result)
 		})
 	}
@@ -190,27 +190,27 @@ func TestFix5_EdgeCaseHandling(t *testing.T) {
 func TestAllFixes_Comprehensive(t *testing.T) {
 	t.Run("10 buckets from 0 to 1 second", func(t *testing.T) {
 		buckets := ExponentialBucketTimeRange(0, 1*time.Second, 10)
-		
+
 		// Fix #2: Exact count
 		if len(buckets) != 10 {
 			t.Errorf("Expected 10 buckets, got %d", len(buckets))
 		}
-		
+
 		// Fix #3: Monotonic
 		for i := 1; i < len(buckets); i++ {
 			if buckets[i] <= buckets[i-1] {
 				t.Errorf("Not monotonic at index %d", i)
 			}
 		}
-		
+
 		// Fix #1: Exponential spacing
 		var ratios []float64
 		for i := 2; i < len(buckets); i++ {
 			if buckets[i-1] > 0 {
 				ratios = append(ratios, buckets[i]/buckets[i-1])
 			}
 		}
-		
+
 		if len(ratios) > 1 {
 			avgRatio := ratios[0]
 			for _, r := range ratios {
@@ -219,15 +219,15 @@ func TestAllFixes_Comprehensive(t *testing.T) {
 				}
 			}
 		}
-		
+
 		// Fix #4: Clean Prometheus output
 		for i, v := range buckets {
 			prometheusStr := fmt.Sprintf("%g", v)
 			if len(prometheusStr) > 12 && v > 0 && v < 10 {
 				t.Errorf("Bucket %d has ugly output: %s", i, prometheusStr)
 			}
 		}
-		
+
 		t.Logf("✓ All fixes verified")
 		t.Logf("  Buckets: %v", buckets)
 		t.Logf("  Exponential ratio: %.6f", ratios[0])