Add common utility methods for calculations

Author: Ajinkya Nahar

compute/calc.go

@@ -0,0 +1,65 @@
+package compute
+
+const (
+	// Up label
+	Up string = "UP"
+	// Down label
+	Down string = "DOWN"
+	// Flat label
+	Flat string = "SAME"
+)
+
+// GetStatsComparison returns the comparison of 2 metrics
+func GetStatsComparison(currentStats float64, previousStats float64) string {
+	if currentStats == previousStats {
+		return Flat
+	} else if currentStats < previousStats {
+		return Down
+	} else {
+		return Up
+	}
+}
+
+// CalculatePercent based on numerator & denominator values
+func CalculatePercent(numerator float64, denominator float64) float64 {
+	if denominator == 0 {
+		return 0.0
+	}
+	return (numerator / denominator) * 100
+}
+
+// Subtract num2 from num1
+func Subtract(num1 float64, num2 float64) float64 {
+	if num2 > num1 {
+		return 0.0
+	}
+	return (num1 - num2)
+}
+
+// Ratio of 2 numbers
+func Ratio(numerator float64, denominator float64) float64 {
+	if denominator == 0 {
+		return 0.0
+	}
+	return (float64(numerator) / float64(denominator))
+}
+
+// SumStats sum each element of a given slice and return the result
+func SumStats(stats []int64) float64 {
+	result := 0.0
+	for _, v := range stats {
+		result += float64(v)
+	}
+	return result
+}
+
+// AggregateStats sum each element of the 2 different stats and returns the results.
+func AggregateStats(stats1 []int64, stats2 []int64) []int64 {
+	if len(stats1) > 0 && len(stats2) > 0 && len(stats2) == len(stats1) {
+		for i := 0; i < len(stats1); i++ {
+			stats1[i] = stats1[i] + stats2[i]
+		}
+	}
+
+	return stats1
+}

compute/calc_test.go

@@ -0,0 +1,63 @@
+package compute
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Check the subtract util method returns expected computed value
+func TestSubtract(t *testing.T) {
+	result := Subtract(540.00, 230.00)
+	assert.Equal(t, result, 310.00)
+
+	result = Subtract(140.00, 230.00)
+	assert.Equal(t, result, 0.00)
+
+	result = Subtract(340.00, 230.00)
+	assert.NotEqual(t, result, 111.00)
+
+}
+
+// Check the calculate percent util method returns expected computed value
+func TestCalculatePercent(t *testing.T) {
+	result := CalculatePercent(500.00, 1000.00)
+	assert.Equal(t, result, 50.00)
+
+	result = CalculatePercent(500.00, 0.00)
+	assert.Equal(t, result, 0.00)
+
+}
+
+// Check the ratio util method returns expected computed value
+func TestRatio(t *testing.T) {
+	result := Ratio(500.00, 1000.00)
+	assert.Equal(t, result, 0.50)
+
+	result = Ratio(750.00, 1000.00)
+	assert.Equal(t, result, 0.75)
+
+	result = Ratio(1500.00, 1000.00)
+	assert.Equal(t, result, 1.5)
+
+	result = Ratio(500.00, 0.00)
+	assert.Equal(t, result, 0.00)
+
+}
+
+// Check the stats comparison util method returns expected trend for different values
+func TestStatsComparison(t *testing.T) {
+	assert.Equal(t, Up, "UP")
+	assert.Equal(t, Down, "DOWN")
+	assert.Equal(t, Flat, "SAME")
+
+	result := GetStatsComparison(1200.00, 1000.00)
+	assert.Equal(t, result, Up)
+
+	result = GetStatsComparison(750.00, 1000.00)
+	assert.Equal(t, result, Down)
+
+	result = GetStatsComparison(1500.00, 1500.00)
+	assert.Equal(t, Flat, result)
+
+}

compute/format.go

@@ -0,0 +1,64 @@
+package compute
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+
+	"github.com/labstack/gommon/log"
+)
+
+// NearestThousandFormat returns a string with %.2f<K/M/B>
+func NearestThousandFormat(count float64) string {
+	var suffix = []string{"K", "M", "B", "T", "Qd", "Qt"}
+	var formattedStr string
+	if count < 1000 {
+		return fmt.Sprintf("%d", int64(count))
+	}
+	exp := (int64)(math.Log(count) / math.Log(1000))
+	if exp <= int64(len(suffix)) {
+		formattedStr = fmt.Sprintf("%.2f%s", count/math.Pow(1000, float64(exp)), suffix[exp-1])
+	}
+	return formattedStr
+}
+
+// RawNumberFormat returns a string with %.2f<K/M/B>
+func RawNumberFormat(metricValue string) int64 {
+	if len(metricValue) <= 0 {
+		return 0
+	}
+	var numberVal int64
+	if len(metricValue) == 1 {
+		numberVal, err := strconv.ParseInt(metricValue, 0, 64)
+		if err != nil {
+			log.Warnf("Failed converting to raw number format: %+v", err)
+		}
+		return numberVal
+	}
+	var metricValueWithoutSuffix, err = strconv.ParseFloat(metricValue[:len(metricValue)-1], 64)
+	if err != nil {
+		log.Fatalf("Failed converting to raw number format %+v", err)
+	}
+	switch metricValue[len(metricValue)-1:] {
+	case "K":
+		numberVal = int64(float64(metricValueWithoutSuffix) * math.Pow(1000, 1.00))
+	case "M":
+		numberVal = int64(float64(metricValueWithoutSuffix) * math.Pow(1000, 2.00))
+	case "B":
+		numberVal = int64(float64(metricValueWithoutSuffix) * math.Pow(1000, 3.00))
+	case "T":
+		numberVal = int64(float64(metricValueWithoutSuffix) * math.Pow(1000, 4.00))
+	case "Qd":
+		numberVal = int64(float64(metricValueWithoutSuffix) * math.Pow(1000, 5.00))
+	case "Qt":
+		numberVal = int64(float64(metricValueWithoutSuffix) * math.Pow(1000, 6.00))
+	default:
+		numberVal, err := strconv.ParseInt(metricValue, 0, 64)
+		if err != nil {
+			log.Fatalf("Failed converting to raw number format: %+v", err)
+		}
+		return numberVal
+	}
+
+	return numberVal
+}

compute/format_test.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"testing"
+)
+
+func TestRawNumberFormat(t *testing.T) {
+	type args struct {
+		metricValue string
+	}
+	tests := []struct {
+		name string
+		args args
+		want int64
+	}{
+		{
+			name: "109",
+			args: args{metricValue: "109"},
+			want: 109,
+		}, {
+			name: "10.39K",
+			args: args{metricValue: "10.39K"},
+			want: 10390,
+		}, {
+			name: "145.78K",
+			args: args{metricValue: "145.78K"},
+			want: 145780,
+		}, {
+			name: "1M",
+			args: args{metricValue: "1M"},
+			want: 1000000,
+		}, {
+			name: "98.87M",
+			args: args{metricValue: "98.87M"},
+			want: 98870000,
+		}, {
+			name: "786.96M",
+			args: args{metricValue: "786.96M"},
+			want: 786960000,
+		}, {
+			name: "1B",
+			args: args{metricValue: "1.00B"},
+			want: 1000000000,
+		}, {
+			name: "12.65B",
+			args: args{metricValue: "12.65B"},
+			want: 12650000000,
+		}, {
+			name: "249.06B",
+			args: args{metricValue: "249.06B"},
+			want: 249060000000,
+		}, {
+			name: "1 trillion",
+			args: args{metricValue: "1T"},
+			want: 1000000000000,
+		}, {
+			name: "653.57 Trillion",
+			args: args{metricValue: "653.57T"},
+			want: 653570000000000,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := RawNumberFormat(tt.args.metricValue); got != tt.want {
+				t.Errorf("RawNumberFormat() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

go.mod

@@ -5,7 +5,6 @@ go 1.15
 require (
 	github.com/avast/retry-go v3.0.0+incompatible
 	github.com/aws/aws-sdk-go v1.36.15
-	github.com/aws/aws-sdk-go-v2 v1.3.1 // indirect
 	github.com/aws/aws-sdk-go-v2/config v1.1.4
 	github.com/aws/aws-sdk-go-v2/service/ssm v1.3.0
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
@@ -14,6 +13,7 @@ require (
 	github.com/google/go-github/v33 v33.0.0
 	github.com/google/uuid v1.1.4
 	github.com/json-iterator/go v1.1.10
+	github.com/labstack/gommon v0.3.0
 	github.com/pkg/errors v0.9.1
 	github.com/sirupsen/logrus v1.7.0
 	github.com/stretchr/testify v1.6.1