feat(metrics): avoid back and forth data conversion

Instead of converting bytes to string and use regex to dedup
new line characters and trim spaces, do the processing
on byte data.

Signed-off-by: AyushSenapati <a.p.senapati008@gmail.com>

Author: AyushSenapati

app/kuma-dp/pkg/dataplane/metrics/server.go

@@ -11,9 +11,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
-	"regexp"
 	"strconv"
-	"strings"
 	"sync"
 	"time"
 
@@ -230,38 +228,53 @@ func processMetrics(metrices <-chan []byte, contentType expfmt.Format) []byte {
 		}
 	}
 
-	str := processNewlineChars(buf.String(), true, true)
-	str = fmt.Sprintf("%s\n", str)
+	processedMetrics := processNewlineChars(buf.Bytes(), true, true)
+	processedMetrics = append(processedMetrics, '\n')
+	buf.Reset()
+	_, err := buf.Write(processedMetrics)
+	if err != nil {
+		panic(err)
+	}
 
-	// if the content type is not OpenMetrics, we don't need to add EOF marker
-	if !(contentType == expfmt.FmtOpenMetrics_1_0_0 || contentType == expfmt.FmtOpenMetrics_0_0_1) {
-		return []byte(str)
+	if contentType == expfmt.FmtOpenMetrics_1_0_0 || contentType == expfmt.FmtOpenMetrics_0_0_1 {
+		// make metrics OpenMetrics compliant
+		buf.Write([]byte("# EOF\n"))
+		return buf.Bytes()
 	}
 
-	// make metrics OpenMetrics compliant
-	return []byte(fmt.Sprintf("%s# EOF\n", str))
+	return buf.Bytes()
 }
 
-// processNewlineChars processes the newline characters in the text.
-// If dedup is true, it replaces multiple newline characters with a single newline character.
+// processNewlineChars processes the newline characters in the byteData.
+// If dedup is true, it replaces multiple consecutive newline characters with a single newline character.
 // If trim is true, it trims the leading and trailing newline characters.
-func processNewlineChars(text string, dedup, trim bool) string {
+func processNewlineChars(byteData []byte, dedup, trim bool) []byte {
 	if dedup {
-		// Create a regular expression to match multiple newline characters.
-		reg := regexp.MustCompile(`(\r\n?|\n){2,}`)
-
-		// Replace all the matches with a single newline character.
-		text = reg.ReplaceAllString(text, "\n")
+		byteData = dedupFn(byteData, '\n', '\n')
 	}
-
 	if trim {
-		// Trim the leading and trailing newline characters.
-		text = strings.TrimFunc(text, func(r rune) bool {
-			return r == '\n'
-		})
+		byteData = bytes.TrimSpace(byteData)
 	}
+	return byteData
+}
 
-	return text
+func dedupFn(input []byte, old, new byte) []byte {
+	var deduped []byte
+
+	var last byte
+	if len(input) > 0 {
+		last = input[0]
+	}
+	for i := 1; i < len(input); i++ {
+		if last == old && input[i] == last {
+			last = new
+			continue
+		}
+		deduped = append(deduped, last)
+		last = input[i]
+	}
+	deduped = append(deduped, last)
+	return deduped
 }
 
 // selectContentType selects the highest priority content type supported by the applications.

app/kuma-dp/pkg/dataplane/metrics/server_test.go

@@ -181,7 +181,7 @@ var _ = Describe("ProcessNewlineChars", func() {
 
 	DescribeTable("should",
 		func(given testCase) {
-			actual := processNewlineChars(given.input, given.deduplicate, given.trim)
+			actual := string(processNewlineChars([]byte(given.input), given.deduplicate, given.trim))
 			Expect(actual).To(Equal(given.expected))
 		},
 		Entry("should not deduplicate or trim newline characters", testCase{
@@ -210,3 +210,19 @@ var _ = Describe("ProcessNewlineChars", func() {
 		}),
 	)
 })
+
+var _ = Describe("Dedup", func() {
+	type testCase struct {
+		input    string
+		expected string
+	}
+	DescribeTable("should", func(given testCase) {
+		actual := string(dedupFn([]byte(given.input), '\n', '\n'))
+		Expect(actual).To(Equal(given.expected))
+	},
+		Entry("should deduplicate newline characters", testCase{
+			input:    "This is a test.\n\n\n\nThis is another test.\n",
+			expected: "This is a test.\nThis is another test.\n",
+		}),
+	)
+})