backend: improve ParseIntervalStringToTimeDuration method performance in gtime package by ~93% (#1237)

* introduce benchmark test

PureNumber-10                 1674 ns/op            2377 B/op         35 allocs/op
Seconds-10                    1646 ns/op            2369 B/op         34 allocs/op
Minutes-10                    1635 ns/op            2369 B/op         34 allocs/op
Hours-10                      1633 ns/op            2369 B/op         34 allocs/op
Days-10                       1719 ns/op            2513 B/op         36 allocs/op
Weeks-10                      1713 ns/op            2513 B/op         36 allocs/op
Months-10                     1710 ns/op            2513 B/op         36 allocs/op
Years-10                      1727 ns/op            2513 B/op         36 allocs/op
Complex-10                    1660 ns/op            2369 B/op         34 allocs/op
WithBrackets-10               1723 ns/op            2385 B/op         36 allocs/op

* improve performance by ~89% with precompiled regex

* improve sec/op by ~25% more. B/op and alloc/op stayed same.

* less allocation for bracket duration and ~8% faster execution

* 0 allocation for pure number case

* rename and slight cpu performance gain

Author: itsmylife

backend/gtime/gtime.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"regexp"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
@@ -154,15 +153,37 @@ func GetIntervalFrom(dsInterval, queryInterval string, queryIntervalMS int64, de
 // ParseIntervalStringToTimeDuration converts a string representation of a expected (i.e. 1m30s) to time.Duration
 // this method copied from grafana/grafana/pkg/tsdb/intervalv2.go
 func ParseIntervalStringToTimeDuration(interval string) (time.Duration, error) {
-	formattedInterval := strings.Replace(strings.Replace(interval, "<", "", 1), ">", "", 1)
-	isPureNum, err := regexp.MatchString(`^\d+$`, formattedInterval)
-	if err != nil {
-		return time.Duration(0), err
+	if len(interval) == 0 {
+		return 0, backend.DownstreamError(fmt.Errorf("invalid interval"))
+	}
+
+	// extract the interval if it is inside brackets i.e. <10m>
+	if interval[0] == '<' {
+		interval = interval[1:]
+	}
+	if len(interval) > 0 && interval[len(interval)-1] == '>' {
+		interval = interval[:len(interval)-1]
 	}
+
+	// Check if string contains only digits
+	isPureNum := true
+	for _, c := range interval {
+		if c < '0' || c > '9' {
+			isPureNum = false
+			break
+		}
+	}
+
+	// if it is number than return it immediately
 	if isPureNum {
-		formattedInterval += "s"
+		num, err := strconv.ParseInt(interval, 10, 64)
+		if err != nil {
+			return 0, err
+		}
+		return time.Duration(num) * time.Second, nil
 	}
-	parsedInterval, err := ParseDuration(formattedInterval)
+
+	parsedInterval, err := ParseDuration(interval)
 	if err != nil {
 		return time.Duration(0), err
 	}

backend/gtime/gtime_bench_test.go

@@ -0,0 +1,36 @@
+package gtime
+
+import (
+	"testing"
+)
+
+// go test -benchmem -run=^$ -bench=BenchmarkParseIntervalStringToTimeDuration$ github.
+// com/grafana/grafana-plugin-sdk-go/backend/gtime/ -memprofile p_mem.out -count 6 | tee p_mem.txt
+func BenchmarkParseIntervalStringToTimeDuration(b *testing.B) {
+	testCases := []struct {
+		name     string
+		interval string
+	}{
+		{"PureNumber", "30"},
+		{"Seconds", "30s"},
+		{"Minutes", "5m"},
+		{"Hours", "2h"},
+		{"Days", "7d"},
+		{"Weeks", "2w"},
+		{"Months", "3M"},
+		{"Years", "1y"},
+		{"Complex", "1h30m"},
+		{"WithBrackets", "<30s>"},
+	}
+
+	for _, tc := range testCases {
+		b.Run(tc.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_, err := ParseIntervalStringToTimeDuration(tc.interval)
+				if err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}

backend/gtime/gtime_test.go

@@ -152,6 +152,7 @@ func TestParseIntervalStringToTimeDuration(t *testing.T) {
 		{inp: "<10s>", duration: 10 * time.Second},
 		{inp: "10s>", duration: 10 * time.Second},
 		{inp: "<10s", duration: 10 * time.Second},
+		{inp: "", err: regexp.MustCompile(`invalid interval`)},
 	}
 	for i, tc := range tcs {
 		t.Run(fmt.Sprintf("testcase %d", i), func(t *testing.T) {