Use const for sigDigits instead of parameter

- Added sigDigits constant with value 6
- Removed sigDigits parameter from roundToSignificantDigits function
- Updated all calls to use the constant
- All tests still passing

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

Author: AkramBitar

platform/common/utils/metrics.go

@@ -33,44 +33,47 @@ func LinearBucketRange(start, end int64, buckets int) []float64 {
 	return bs
 }
 
-const precision = float64(time.Millisecond)
+const (
+	precision = float64(time.Millisecond)
+	sigDigits = 6 // Number of significant digits for rounding bucket values
+)
 
 // ExponentialBucketTimeRange creates a bucket set for a histogram
 // that has exponentially increasing intervals between the values, e.g. 0, 0.5, 1, 2, 4, 8, ...
 // Fixed to guarantee exactly 'buckets' number of buckets and produce clean floating-point values.
 func ExponentialBucketTimeRange(start, end time.Duration, buckets int) []float64 {
 	if buckets <= 1 {
-		return []float64{roundToSignificantDigits(start.Seconds(), 6)}
+		return []float64{roundToSignificantDigits(start.Seconds())}
 	}
 
 	interval := end - start
 	if interval <= 0 {
-		return []float64{roundToSignificantDigits(start.Seconds(), 6)}
+		return []float64{roundToSignificantDigits(start.Seconds())}
 	}
 
 	// 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))
+	bs = append(bs, roundToSignificantDigits(start.Seconds()))
 
 	// Generate exactly buckets-1 additional buckets
 	for i := 1; i < buckets; i++ {
 		v := time.Duration(math.Pow(factor, float64(i)) * precision)
 		if v > interval {
 			v = interval
 		}
-		// Round to 6 significant digits to avoid ugly floating-point representations
-		bs = append(bs, roundToSignificantDigits((start+v).Seconds(), 6))
+		// Round to sigDigits significant digits to avoid ugly floating-point representations
+		bs = append(bs, roundToSignificantDigits((start+v).Seconds()))
 	}
 
 	return bs
 }
 
-// roundToSignificantDigits rounds a float64 to n significant digits
+// roundToSignificantDigits rounds a float64 to sigDigits significant digits
 // This produces cleaner values for Prometheus metrics (e.g., 0.001 instead of 0.0009999999999999999)
-func roundToSignificantDigits(value float64, sigDigits int) float64 {
+func roundToSignificantDigits(value float64) float64 {
 	if value == 0 {
 		return 0
 	}