diff --git a/pkg/query-service/converter/converter.go b/pkg/query-service/converter/converter.go index 88aa27b80f59..35042780a149 100644 --- a/pkg/query-service/converter/converter.go +++ b/pkg/query-service/converter/converter.go @@ -43,17 +43,17 @@ var ( // FromUnit returns a converter for the given unit func FromUnit(u Unit) Converter { switch u { - case "ns", "us", "µs", "ms", "s", "m", "h", "d": + case "ns", "us", "µs", "ms", "s", "m", "h", "d", "min": return DurationConverter - case "bytes", "decbytes", "bits", "decbits", "kbytes", "decKbytes", "deckbytes", "mbytes", "decMbytes", "decmbytes", "gbytes", "decGbytes", "decgbytes", "tbytes", "decTbytes", "dectbytes", "pbytes", "decPbytes", "decpbytes": + case "bytes", "decbytes", "bits", "decbits", "kbytes", "decKbytes", "deckbytes", "mbytes", "decMbytes", "decmbytes", "gbytes", "decGbytes", "decgbytes", "tbytes", "decTbytes", "dectbytes", "pbytes", "decPbytes", "decpbytes", "By", "kBy", "MBy", "GBy", "TBy", "PBy": return DataConverter - case "binBps", "Bps", "binbps", "bps", "KiBs", "Kibits", "KBs", "Kbits", "MiBs", "Mibits", "MBs", "Mbits", "GiBs", "Gibits", "GBs", "Gbits", "TiBs", "Tibits", "TBs", "Tbits", "PiBs", "Pibits", "PBs", "Pbits": + case "binBps", "Bps", "binbps", "bps", "KiBs", "Kibits", "KBs", "Kbits", "MiBs", "Mibits", "MBs", "Mbits", "GiBs", "Gibits", "GBs", "Gbits", "TiBs", "Tibits", "TBs", "Tbits", "PiBs", "Pibits", "PBs", "Pbits", "By/s", "kBy/s", "MBy/s", "GBy/s", "TBy/s", "PBy/s", "bit/s", "kbit/s", "Mbit/s", "Gbit/s", "Tbit/s", "Pbit/s": return DataRateConverter - case "percent", "percentunit": + case "percent", "percentunit", "%": return PercentConverter case "bool", "bool_yes_no", "bool_true_false", "bool_1_0": return BoolConverter - case "cps", "ops", "reqps", "rps", "wps", "iops", "cpm", "opm", "rpm", "wpm": + case "cps", "ops", "reqps", "rps", "wps", "iops", "cpm", "opm", "rpm", "wpm", "{count}/s", "{ops}/s", "{req}/s", "{read}/s", "{write}/s", "{iops}/s", "{count}/min", "{ops}/min", "{read}/min", "{write}/min": return ThroughputConverter default: return NoneConverter diff --git a/pkg/query-service/converter/data.go b/pkg/query-service/converter/data.go index e1d447af82a8..8234ee3db776 100644 --- a/pkg/query-service/converter/data.go +++ b/pkg/query-service/converter/data.go @@ -60,7 +60,7 @@ func (*dataConverter) Name() string { func FromDataUnit(u Unit) float64 { switch u { - case "bytes": // base 2 + case "bytes", "By": // base 2 return Byte case "decbytes": // base 10 return Byte @@ -68,23 +68,23 @@ func FromDataUnit(u Unit) float64 { return Bit case "decbits": // base 10 return Bit - case "kbytes": // base 2 + case "kbytes", "kBy": // base 2 return Kibibyte case "decKbytes", "deckbytes": // base 10 return Kilobyte - case "mbytes": // base 2 + case "mbytes", "MBy": // base 2 return Mebibyte case "decMbytes", "decmbytes": // base 10 return Megabyte - case "gbytes": // base 2 + case "gbytes", "GBy": // base 2 return Gibibyte case "decGbytes", "decgbytes": // base 10 return Gigabyte - case "tbytes": // base 2 + case "tbytes", "TBy": // base 2 return Tebibyte case "decTbytes", "dectbytes": // base 10 return Terabyte - case "pbytes": // base 2 + case "pbytes", "PBy": // base 2 return Pebibyte case "decPbytes", "decpbytes": // base 10 return Petabyte diff --git a/pkg/query-service/converter/data_rate.go b/pkg/query-service/converter/data_rate.go index 7b5fcebdcaa4..6a0812d541ab 100644 --- a/pkg/query-service/converter/data_rate.go +++ b/pkg/query-service/converter/data_rate.go @@ -59,51 +59,51 @@ func FromDataRateUnit(u Unit) float64 { switch u { case "binBps": // bytes/sec(IEC) return BytePerSecond - case "Bps": // bytes/sec(SI) + case "Bps", "By/s": // bytes/sec(SI) return BytePerSecond case "binbps": // bits/sec(IEC) return BitPerSecond - case "bps": // bits/sec(SI) + case "bps", "bit/s": // bits/sec(SI) return BitPerSecond case "KiBs": // kibibytes/sec return KibibytePerSecond case "Kibits": // kibibits/sec return KibibitPerSecond - case "KBs": // kilobytes/sec + case "KBs", "kBy/s": // kilobytes/sec return KilobytePerSecond - case "Kbits": // kilobits/sec + case "Kbits", "kbit/s": // kilobits/sec return KilobitPerSecond case "MiBs": // mebibytes/sec return MebibytePerSecond case "Mibits": // mebibits/sec return MebibitPerSecond - case "MBs": // megabytes/sec + case "MBs", "MBy/s": // megabytes/sec return MegabytePerSecond - case "Mbits": // megabits/sec + case "Mbits", "Mbit/s": // megabits/sec return MegabitPerSecond case "GiBs": // gibibytes/sec return GibibytePerSecond case "Gibits": // gibibits/sec return GibibitPerSecond - case "GBs": // gigabytes/sec + case "GBs", "GBy/s": // gigabytes/sec return GigabytePerSecond - case "Gbits": // gigabits/sec + case "Gbits", "Gbit/s": // gigabits/sec return GigabitPerSecond case "TiBs": // tebibytes/sec return TebibytePerSecond case "Tibits": // tebibits/sec return TebibitPerSecond - case "TBs": // terabytes/sec + case "TBs", "TBy/s": // terabytes/sec return TerabytePerSecond - case "Tbits": // terabits/sec + case "Tbits", "Tbit/s": // terabits/sec return TerabitPerSecond case "PiBs": // pebibytes/sec return PebibytePerSecond case "Pibits": // pebibits/sec return PebibitPerSecond - case "PBs": // petabytes/sec + case "PBs", "PBy/s": // petabytes/sec return PetabytePerSecond - case "Pbits": // petabits/sec + case "Pbits", "Pbit/s": // petabits/sec return PetabitPerSecond default: return 1 diff --git a/pkg/query-service/converter/data_rate_test.go b/pkg/query-service/converter/data_rate_test.go index dda0f7886e2d..68d8d34c022e 100644 --- a/pkg/query-service/converter/data_rate_test.go +++ b/pkg/query-service/converter/data_rate_test.go @@ -36,10 +36,16 @@ func TestDataRate(t *testing.T) { // 8 bits = 1 byte assert.Equal(t, Value{F: 1, U: "binBps"}, dataRateConverter.Convert(Value{F: 8, U: "binbps"}, "binBps")) + // 8 bits = 1 byte + assert.Equal(t, Value{F: 1, U: "Bps"}, dataRateConverter.Convert(Value{F: 8, U: "bps"}, "Bps")) + // 8 bits = 1 byte + assert.Equal(t, Value{F: 1, U: "By/s"}, dataRateConverter.Convert(Value{F: 8, U: "bit/s"}, "By/s")) // 1024 bytes = 1 kbytes assert.Equal(t, Value{F: 1, U: "KiBs"}, dataRateConverter.Convert(Value{F: 1024, U: "binBps"}, "KiBs")) // 1 byte = 8 bits assert.Equal(t, Value{F: 8, U: "binbps"}, dataRateConverter.Convert(Value{F: 1, U: "binBps"}, "binbps")) + // 1 byte = 8 bits + assert.Equal(t, Value{F: 8, U: "bit/s"}, dataRateConverter.Convert(Value{F: 1, U: "Bps"}, "bit/s")) // 1 mbytes = 1024 kbytes assert.Equal(t, Value{F: 1, U: "MiBs"}, dataRateConverter.Convert(Value{F: 1024, U: "KiBs"}, "MiBs")) // 1 kbytes = 1024 bytes @@ -57,6 +63,10 @@ func TestDataRate(t *testing.T) { // 1 gbytes = 1024 * 1024 kbytes assert.Equal(t, Value{F: 1024 * 1024, U: "KiBs"}, dataRateConverter.Convert(Value{F: 1, U: "GiBs"}, "KiBs")) // 1 gbytes = 1024 * 1024 * 1024 bytes + assert.Equal(t, Value{F: (1024 * 1024 * 1024 * 8) / 1024, U: "Kibits"}, dataRateConverter.Convert(Value{F: 1, U: "GiBs"}, "Kibits")) + // 1 gbytes = 1024 * 1024 * 1024 bytes + assert.Equal(t, Value{F: float64(1024*1024*1024) / 1000.0, U: "kBy/s"}, dataRateConverter.Convert(Value{F: 1, U: "GiBs"}, "kBy/s")) + // 1 gbytes = 1024 * 1024 * 1024 bytes assert.Equal(t, Value{F: 1024 * 1024 * 1024, U: "binBps"}, dataRateConverter.Convert(Value{F: 1, U: "GiBs"}, "binBps")) // 1024 * 1024 bytes = 1 mbytes assert.Equal(t, Value{F: 1, U: "MiBs"}, dataRateConverter.Convert(Value{F: 1024 * 1024, U: "binBps"}, "MiBs")) diff --git a/pkg/query-service/converter/data_test.go b/pkg/query-service/converter/data_test.go index b484b8172df7..9b6f07e859dc 100644 --- a/pkg/query-service/converter/data_test.go +++ b/pkg/query-service/converter/data_test.go @@ -10,8 +10,10 @@ func TestData(t *testing.T) { dataConverter := NewDataConverter() // 8 bits = 1 byte assert.Equal(t, Value{F: 1, U: "bytes"}, dataConverter.Convert(Value{F: 8, U: "bits"}, "bytes")) + assert.Equal(t, Value{F: 1, U: "By"}, dataConverter.Convert(Value{F: 8, U: "bits"}, "By")) // 1024 bytes = 1 kbytes assert.Equal(t, Value{F: 1, U: "kbytes"}, dataConverter.Convert(Value{F: 1024, U: "bytes"}, "kbytes")) + assert.Equal(t, Value{F: 1, U: "kBy"}, dataConverter.Convert(Value{F: 1024, U: "bytes"}, "kBy")) // 1 byte = 8 bits assert.Equal(t, Value{F: 8, U: "bits"}, dataConverter.Convert(Value{F: 1, U: "bytes"}, "bits")) // 1 mbytes = 1024 kbytes @@ -20,6 +22,7 @@ func TestData(t *testing.T) { assert.Equal(t, Value{F: 1024, U: "bytes"}, dataConverter.Convert(Value{F: 1, U: "kbytes"}, "bytes")) // 1024 kbytes = 1 mbytes assert.Equal(t, Value{F: 1, U: "mbytes"}, dataConverter.Convert(Value{F: 1024, U: "kbytes"}, "mbytes")) + assert.Equal(t, Value{F: 1, U: "MBy"}, dataConverter.Convert(Value{F: 1024, U: "kbytes"}, "MBy")) // 1 mbytes = 1024 * 1024 bytes assert.Equal(t, Value{F: 1024 * 1024, U: "bytes"}, dataConverter.Convert(Value{F: 1, U: "mbytes"}, "bytes")) // 1024 mbytes = 1 gbytes @@ -42,6 +45,10 @@ func TestData(t *testing.T) { assert.Equal(t, Value{F: 1024 * 1024 * 1024 * 1024, U: "bytes"}, dataConverter.Convert(Value{F: 1, U: "tbytes"}, "bytes")) // 1024 tbytes = 1 pbytes assert.Equal(t, Value{F: 1, U: "pbytes"}, dataConverter.Convert(Value{F: 1024, U: "tbytes"}, "pbytes")) + // 1024 tbytes = 1 pbytes + assert.Equal(t, Value{F: 1, U: "PBy"}, dataConverter.Convert(Value{F: 1024, U: "tbytes"}, "PBy")) // 1 pbytes = 1024 tbytes assert.Equal(t, Value{F: 1024, U: "tbytes"}, dataConverter.Convert(Value{F: 1, U: "pbytes"}, "tbytes")) + // 1024 pbytes = 1 tbytes + assert.Equal(t, Value{F: 1024, U: "TBy"}, dataConverter.Convert(Value{F: 1, U: "pbytes"}, "TBy")) } diff --git a/pkg/query-service/converter/percent_converter.go b/pkg/query-service/converter/percent_converter.go index 166b89b54030..275d2e2cb650 100644 --- a/pkg/query-service/converter/percent_converter.go +++ b/pkg/query-service/converter/percent_converter.go @@ -13,7 +13,7 @@ func (*percentConverter) Name() string { func FromPercentUnit(u Unit) float64 { switch u { - case "percent": + case "percent", "%": return 1 case "percentunit": return 100 diff --git a/pkg/query-service/converter/percent_converter_test.go b/pkg/query-service/converter/percent_converter_test.go index 5001ef19645d..7447aa837020 100644 --- a/pkg/query-service/converter/percent_converter_test.go +++ b/pkg/query-service/converter/percent_converter_test.go @@ -13,4 +13,5 @@ func TestPercentConverter(t *testing.T) { assert.Equal(t, Value{F: 100, U: "percent"}, percentConverter.Convert(Value{F: 1, U: "percentunit"}, "percent")) assert.Equal(t, Value{F: 1, U: "percentunit"}, percentConverter.Convert(Value{F: 100, U: "percent"}, "percentunit")) assert.Equal(t, Value{F: 0.01, U: "percentunit"}, percentConverter.Convert(Value{F: 1, U: "percent"}, "percentunit")) + assert.Equal(t, Value{F: 1, U: "percent"}, percentConverter.Convert(Value{F: 1, U: "%"}, "percent")) } diff --git a/pkg/query-service/converter/time.go b/pkg/query-service/converter/time.go index a1ca23a64cbd..122bec00854f 100644 --- a/pkg/query-service/converter/time.go +++ b/pkg/query-service/converter/time.go @@ -41,7 +41,7 @@ func FromTimeUnit(u Unit) Duration { return Decisecond case "s": return Second - case "m": + case "m", "min": return Minute case "h": return Hour diff --git a/pkg/query-service/converter/time_test.go b/pkg/query-service/converter/time_test.go index 910b82e16df5..b37c86e83441 100644 --- a/pkg/query-service/converter/time_test.go +++ b/pkg/query-service/converter/time_test.go @@ -24,6 +24,8 @@ func TestDurationConvert(t *testing.T) { assert.Equal(t, Value{F: 60, U: "s"}, timeConverter.Convert(Value{F: 1, U: "m"}, "s")) // 60 m = 1 h assert.Equal(t, Value{F: 1, U: "h"}, timeConverter.Convert(Value{F: 60, U: "m"}, "h")) + // 60 min = 1 h + assert.Equal(t, Value{F: 1, U: "h"}, timeConverter.Convert(Value{F: 60, U: "min"}, "h")) // 168 h = 1 w assert.Equal(t, Value{F: 1, U: "w"}, timeConverter.Convert(Value{F: 168, U: "h"}, "w")) // 1 h = 60 m diff --git a/pkg/query-service/formatter/data.go b/pkg/query-service/formatter/data.go index e75dd0e68381..d13523373bec 100644 --- a/pkg/query-service/formatter/data.go +++ b/pkg/query-service/formatter/data.go @@ -20,7 +20,7 @@ func (*dataFormatter) Name() string { func (f *dataFormatter) Format(value float64, unit string) string { switch unit { - case "bytes": + case "bytes", "By": return humanize.IBytes(uint64(value)) case "decbytes": return humanize.Bytes(uint64(value)) @@ -28,23 +28,23 @@ func (f *dataFormatter) Format(value float64, unit string) string { return humanize.IBytes(uint64(value * converter.Bit)) case "decbits": return humanize.Bytes(uint64(value * converter.Bit)) - case "kbytes": + case "kbytes", "kBy": return humanize.IBytes(uint64(value * converter.Kibibit)) case "decKbytes", "deckbytes": return humanize.IBytes(uint64(value * converter.Kilobit)) - case "mbytes": + case "mbytes", "MBy": return humanize.IBytes(uint64(value * converter.Mebibit)) case "decMbytes", "decmbytes": return humanize.Bytes(uint64(value * converter.Megabit)) - case "gbytes": + case "gbytes", "GBy": return humanize.IBytes(uint64(value * converter.Gibibit)) case "decGbytes", "decgbytes": return humanize.Bytes(uint64(value * converter.Gigabit)) - case "tbytes": + case "tbytes", "TBy": return humanize.IBytes(uint64(value * converter.Tebibit)) case "decTbytes", "dectbytes": return humanize.Bytes(uint64(value * converter.Terabit)) - case "pbytes": + case "pbytes", "PBy": return humanize.IBytes(uint64(value * converter.Pebibit)) case "decPbytes", "decpbytes": return humanize.Bytes(uint64(value * converter.Petabit)) diff --git a/pkg/query-service/formatter/data_rate.go b/pkg/query-service/formatter/data_rate.go index 011c4339a204..df328a38267c 100644 --- a/pkg/query-service/formatter/data_rate.go +++ b/pkg/query-service/formatter/data_rate.go @@ -22,51 +22,51 @@ func (f *dataRateFormatter) Format(value float64, unit string) string { switch unit { case "binBps": return humanize.IBytes(uint64(value)) + "/s" - case "Bps": + case "Bps", "By/s": return humanize.Bytes(uint64(value)) + "/s" case "binbps": return humanize.IBytes(uint64(value*converter.BitPerSecond)) + "/s" - case "bps": + case "bps", "bit/s": return humanize.Bytes(uint64(value*converter.BitPerSecond)) + "/s" case "KiBs": return humanize.IBytes(uint64(value*converter.KibibitPerSecond)) + "/s" case "Kibits": return humanize.IBytes(uint64(value*converter.KibibytePerSecond)) + "/s" - case "KBs": + case "KBs", "kBy/s": return humanize.IBytes(uint64(value*converter.KilobitPerSecond)) + "/s" - case "Kbits": + case "Kbits", "kbit/s": return humanize.IBytes(uint64(value*converter.KilobytePerSecond)) + "/s" case "MiBs": return humanize.IBytes(uint64(value*converter.MebibitPerSecond)) + "/s" case "Mibits": return humanize.IBytes(uint64(value*converter.MebibytePerSecond)) + "/s" - case "MBs": + case "MBs", "MBy/s": return humanize.IBytes(uint64(value*converter.MegabitPerSecond)) + "/s" - case "Mbits": + case "Mbits", "Mbit/s": return humanize.IBytes(uint64(value*converter.MegabytePerSecond)) + "/s" case "GiBs": return humanize.IBytes(uint64(value*converter.GibibitPerSecond)) + "/s" case "Gibits": return humanize.IBytes(uint64(value*converter.GibibytePerSecond)) + "/s" - case "GBs": + case "GBs", "GBy/s": return humanize.IBytes(uint64(value*converter.GigabitPerSecond)) + "/s" - case "Gbits": + case "Gbits", "Gbit/s": return humanize.IBytes(uint64(value*converter.GigabytePerSecond)) + "/s" case "TiBs": return humanize.IBytes(uint64(value*converter.TebibitPerSecond)) + "/s" case "Tibits": return humanize.IBytes(uint64(value*converter.TebibytePerSecond)) + "/s" - case "TBs": + case "TBs", "TBy/s": return humanize.IBytes(uint64(value*converter.TerabitPerSecond)) + "/s" - case "Tbits": + case "Tbits", "Tbit/s": return humanize.IBytes(uint64(value*converter.TerabytePerSecond)) + "/s" case "PiBs": return humanize.IBytes(uint64(value*converter.PebibitPerSecond)) + "/s" case "Pibits": return humanize.IBytes(uint64(value*converter.PebibytePerSecond)) + "/s" - case "PBs": + case "PBs", "PBy/s": return humanize.IBytes(uint64(value*converter.PetabitPerSecond)) + "/s" - case "Pbits": + case "Pbits", "Pbit/s": return humanize.IBytes(uint64(value*converter.PetabytePerSecond)) + "/s" } // When unit is not matched, return the value as it is. diff --git a/pkg/query-service/formatter/data_test.go b/pkg/query-service/formatter/data_test.go index b5da03cec5b7..1ae9dcae5df2 100644 --- a/pkg/query-service/formatter/data_test.go +++ b/pkg/query-service/formatter/data_test.go @@ -10,14 +10,25 @@ func TestData(t *testing.T) { dataFormatter := NewDataFormatter() assert.Equal(t, "1 B", dataFormatter.Format(1, "bytes")) + assert.Equal(t, "1 B", dataFormatter.Format(1, "By")) assert.Equal(t, "1.0 KiB", dataFormatter.Format(1024, "bytes")) + assert.Equal(t, "1.0 KiB", dataFormatter.Format(1024, "By")) assert.Equal(t, "2.3 GiB", dataFormatter.Format(2.3*1024, "mbytes")) + assert.Equal(t, "2.3 GiB", dataFormatter.Format(2.3*1024, "MBy")) assert.Equal(t, "1.0 MiB", dataFormatter.Format(1024*1024, "bytes")) + assert.Equal(t, "1.0 MiB", dataFormatter.Format(1024*1024, "By")) assert.Equal(t, "69 TiB", dataFormatter.Format(69*1024*1024, "mbytes")) + assert.Equal(t, "69 TiB", dataFormatter.Format(69*1024*1024, "MBy")) assert.Equal(t, "102 KiB", dataFormatter.Format(102*1024, "bytes")) + assert.Equal(t, "102 KiB", dataFormatter.Format(102*1024, "By")) assert.Equal(t, "240 MiB", dataFormatter.Format(240*1024, "kbytes")) + assert.Equal(t, "240 MiB", dataFormatter.Format(240*1024, "kBy")) assert.Equal(t, "1.0 GiB", dataFormatter.Format(1024*1024, "kbytes")) + assert.Equal(t, "1.0 GiB", dataFormatter.Format(1024*1024, "kBy")) assert.Equal(t, "23 GiB", dataFormatter.Format(23*1024*1024, "kbytes")) + assert.Equal(t, "23 GiB", dataFormatter.Format(23*1024*1024, "kBy")) assert.Equal(t, "32 TiB", dataFormatter.Format(32*1024*1024*1024, "kbytes")) + assert.Equal(t, "32 TiB", dataFormatter.Format(32*1024*1024*1024, "kBy")) assert.Equal(t, "24 MiB", dataFormatter.Format(24, "mbytes")) + assert.Equal(t, "24 MiB", dataFormatter.Format(24, "MBy")) } diff --git a/pkg/query-service/formatter/formatter.go b/pkg/query-service/formatter/formatter.go index 08e4dfd15eb3..74ecbc7224b5 100644 --- a/pkg/query-service/formatter/formatter.go +++ b/pkg/query-service/formatter/formatter.go @@ -18,17 +18,17 @@ var ( func FromUnit(u string) Formatter { switch u { - case "ns", "us", "µs", "ms", "s", "m", "h", "d": + case "ns", "us", "µs", "ms", "s", "m", "h", "d", "min": return DurationFormatter - case "bytes", "decbytes", "bits", "decbits", "kbytes", "decKbytes", "deckbytes", "mbytes", "decMbytes", "decmbytes", "gbytes", "decGbytes", "decgbytes", "tbytes", "decTbytes", "dectbytes", "pbytes", "decPbytes", "decpbytes": + case "bytes", "decbytes", "bits", "decbits", "kbytes", "decKbytes", "deckbytes", "mbytes", "decMbytes", "decmbytes", "gbytes", "decGbytes", "decgbytes", "tbytes", "decTbytes", "dectbytes", "pbytes", "decPbytes", "decpbytes", "By", "kBy", "MBy", "GBy", "TBy", "PBy": return DataFormatter - case "binBps", "Bps", "binbps", "bps", "KiBs", "Kibits", "KBs", "Kbits", "MiBs", "Mibits", "MBs", "Mbits", "GiBs", "Gibits", "GBs", "Gbits", "TiBs", "Tibits", "TBs", "Tbits", "PiBs", "Pibits", "PBs", "Pbits": + case "binBps", "Bps", "binbps", "bps", "KiBs", "Kibits", "KBs", "Kbits", "MiBs", "Mibits", "MBs", "Mbits", "GiBs", "Gibits", "GBs", "Gbits", "TiBs", "Tibits", "TBs", "Tbits", "PiBs", "Pibits", "PBs", "Pbits", "By/s", "kBy/s", "MBy/s", "GBy/s", "TBy/s", "PBy/s", "bit/s", "kbit/s", "Mbit/s", "Gbit/s", "Tbit/s", "Pbit/s": return DataRateFormatter - case "percent", "percentunit": + case "percent", "percentunit", "%": return PercentFormatter case "bool", "bool_yes_no", "bool_true_false", "bool_1_0": return BoolFormatter - case "cps", "ops", "reqps", "rps", "wps", "iops", "cpm", "opm", "rpm", "wpm": + case "cps", "ops", "reqps", "rps", "wps", "iops", "cpm", "opm", "rpm", "wpm", "{count}/s", "{ops}/s", "{req}/s", "{read}/s", "{write}/s", "{iops}/s", "{count}/min", "{ops}/min", "{read}/min", "{write}/min": return ThroughputFormatter default: return NoneFormatter diff --git a/pkg/query-service/formatter/percent.go b/pkg/query-service/formatter/percent.go index 9740737a2e27..2d582855d7d3 100644 --- a/pkg/query-service/formatter/percent.go +++ b/pkg/query-service/formatter/percent.go @@ -22,7 +22,7 @@ func toPercentUnit(value float64, decimals DecimalCount) string { func (f *percentFormatter) Format(value float64, unit string) string { switch unit { - case "percent": + case "percent", "%": return toPercent(value, nil) case "percentunit": return toPercentUnit(value, nil) diff --git a/pkg/query-service/formatter/throughput.go b/pkg/query-service/formatter/throughput.go index 6bad95e019d9..1c3ada9bd1d5 100644 --- a/pkg/query-service/formatter/throughput.go +++ b/pkg/query-service/formatter/throughput.go @@ -22,25 +22,25 @@ func simpleCountUnit(value float64, decimals *int, symbol string) string { func (f *throughputFormatter) Format(value float64, unit string) string { switch unit { - case "cps": + case "cps", "{count}/s": return simpleCountUnit(value, nil, "c/s") - case "ops": + case "ops", "{ops}/s": return simpleCountUnit(value, nil, "op/s") - case "reqps": + case "reqps", "{req}/s": return simpleCountUnit(value, nil, "req/s") - case "rps": + case "rps", "{read}/s": return simpleCountUnit(value, nil, "r/s") - case "wps": + case "wps", "{write}/s": return simpleCountUnit(value, nil, "w/s") - case "iops": + case "iops", "{iops}/s": return simpleCountUnit(value, nil, "iops") - case "cpm": + case "cpm", "{count}/min": return simpleCountUnit(value, nil, "c/m") - case "opm": + case "opm", "{ops}/min": return simpleCountUnit(value, nil, "op/m") - case "rpm": + case "rpm", "{read}/min": return simpleCountUnit(value, nil, "r/m") - case "wpm": + case "wpm", "{write}/min": return simpleCountUnit(value, nil, "w/m") } // When unit is not matched, return the value as it is. diff --git a/pkg/query-service/formatter/throughput_test.go b/pkg/query-service/formatter/throughput_test.go index acb7c37adf9d..004f45e10112 100644 --- a/pkg/query-service/formatter/throughput_test.go +++ b/pkg/query-service/formatter/throughput_test.go @@ -10,6 +10,11 @@ func TestThroughput(t *testing.T) { throughputFormatter := NewThroughputFormatter() assert.Equal(t, "10 req/s", throughputFormatter.Format(10, "reqps")) + assert.Equal(t, "10 req/s", throughputFormatter.Format(10, "{req}/s")) assert.Equal(t, "1K req/s", throughputFormatter.Format(1000, "reqps")) + assert.Equal(t, "1K req/s", throughputFormatter.Format(1000, "{req}/s")) assert.Equal(t, "1M req/s", throughputFormatter.Format(1000000, "reqps")) + assert.Equal(t, "1M req/s", throughputFormatter.Format(1000000, "{req}/s")) + assert.Equal(t, "10 c/m", throughputFormatter.Format(10, "cpm")) + assert.Equal(t, "10 c/m", throughputFormatter.Format(10, "{count}/min")) } diff --git a/pkg/query-service/formatter/time.go b/pkg/query-service/formatter/time.go index 062f9acde5e8..df1b2fcfcd98 100644 --- a/pkg/query-service/formatter/time.go +++ b/pkg/query-service/formatter/time.go @@ -26,7 +26,7 @@ func (f *durationFormatter) Format(value float64, unit string) string { return toMilliSeconds(value) case "s": return toSeconds(value) - case "m": + case "m", "min": return toMinutes(value) case "h": return toHours(value) diff --git a/pkg/query-service/formatter/time_test.go b/pkg/query-service/formatter/time_test.go index daa270e1ff2f..8224eaea9b88 100644 --- a/pkg/query-service/formatter/time_test.go +++ b/pkg/query-service/formatter/time_test.go @@ -26,4 +26,5 @@ func TestDuration(t *testing.T) { assert.Equal(t, "1.82 min", durationFormatter.Format(109200000000, "ns")) assert.Equal(t, "1.27 day", durationFormatter.Format(109800000000000, "ns")) assert.Equal(t, "2 day", durationFormatter.Format(172800000, "ms")) + assert.Equal(t, "1 hour", durationFormatter.Format(60, "min")) } diff --git a/pkg/query-service/rules/threshold_rule_test.go b/pkg/query-service/rules/threshold_rule_test.go index 9735fe985238..94b4f7c5c658 100644 --- a/pkg/query-service/rules/threshold_rule_test.go +++ b/pkg/query-service/rules/threshold_rule_test.go @@ -1334,6 +1334,35 @@ func TestThresholdRuleUnitCombinations(t *testing.T) { matchType: "1", // Once target: 200, // 200 GB }, + { + targetUnit: "decgbytes", + yAxisUnit: "By", + values: [][]interface{}{ + {float64(2863284053), "attr", time.Now()}, // 2.86 GB + {float64(2863388842), "attr", time.Now().Add(1 * time.Second)}, // 2.86 GB + {float64(300947400), "attr", time.Now().Add(2 * time.Second)}, // 0.3 GB + {float64(299316000), "attr", time.Now().Add(3 * time.Second)}, // 0.3 GB + {float64(66640400.00000001), "attr", time.Now().Add(4 * time.Second)}, // 66.64 MB + }, + expectAlerts: 0, + compareOp: "1", // Above + matchType: "1", // Once + target: 200, // 200 GB + }, + { + targetUnit: "h", + yAxisUnit: "min", + values: [][]interface{}{ + {float64(55), "attr", time.Now()}, // 55 minutes + {float64(57), "attr", time.Now().Add(1 * time.Minute)}, // 57 minutes + {float64(30), "attr", time.Now().Add(2 * time.Minute)}, // 30 minutes + {float64(29), "attr", time.Now().Add(3 * time.Minute)}, // 29 minutes + }, + expectAlerts: 0, + compareOp: "1", // Above + matchType: "1", // Once + target: 1, // 1 hour + }, } logger := instrumentationtest.New().Logger() diff --git a/pkg/query-service/rules/threshold_rule_test_data.go b/pkg/query-service/rules/threshold_rule_test_data.go index cc301c5aa91b..8e447e0a45c8 100644 --- a/pkg/query-service/rules/threshold_rule_test_data.go +++ b/pkg/query-service/rules/threshold_rule_test_data.go @@ -86,5 +86,26 @@ var ( matchType: "1", // Once target: 200, // 200 GB }, + { + targetUnit: "decgbytes", + yAxisUnit: "By", + values: [][]interface{}{ + {float64(2863284053), "attr", time.Now()}, // 2.86 GB + {float64(2863388842), "attr", time.Now().Add(1 * time.Second)}, // 2.86 GB + {float64(300947400), "attr", time.Now().Add(2 * time.Second)}, // 0.3 GB + {float64(299316000), "attr", time.Now().Add(3 * time.Second)}, // 0.3 GB + {float64(66640400.00000001), "attr", time.Now().Add(4 * time.Second)}, // 66.64 MB + }, + metaValues: [][]interface{}{}, + createTableValues: [][]interface{}{ + {"statement"}, + }, + attrMetaValues: [][]interface{}{}, + resourceMetaValues: [][]interface{}{}, + expectAlerts: 0, + compareOp: "1", // Above + matchType: "1", // Once + target: 200, // 200 GB + }, } )