add a lru cache to regexp decoder

Often, regexp decoder can run repeatedly on the same input. An common
example is matching cgroup path in a chain like so:

```
- name: cgroup
- name: regexp
  regexps:
  - ^.*(system.slice).*$
```

In these cases, the overhead of regexp matching can often be noticable.
Since the input does not vary too often, we can add a cache here to skip
the overhead of regex matching. This is implemented as an LRU cache to
prevent the cache from growing infinitely, especially in cases where we
have many short-live cgroups. The previous example can be written aborts

```
- name: cgroup
- name: regexp
  lru_cache_size: 1024
  regexps:
  - ^.*(system.slice).*$
```

Signed-off-by: Daniel Dao <dqminh@cloudflare.com>

Author: dqminh

.vscode/config-schema.yaml

@@ -145,7 +145,10 @@ definitions:
                 type: object
               allow_unknown:
                 type: boolean
+              lru_cache_size:
+                type: number
               regexps:
                 type: array
                 items:
                   type: string
+

config/config.go

@@ -73,6 +73,7 @@ type Decoder struct {
 	StaticMap    map[string]string `yaml:"static_map"`
 	Regexps      []string          `yaml:"regexps"`
 	AllowUnknown bool              `yaml:"allow_unknown"`
+	LruCacheSize int               `yaml:"lru_cache_size"`
 }
 
 // HistogramBucketType is an enum to define how to interpret histogram

decoder/regexp.go

@@ -6,22 +6,32 @@ import (
 	"regexp"
 
 	"github.com/cloudflare/ebpf_exporter/v2/config"
+	lru "github.com/hashicorp/golang-lru/v2"
 )
 
 // Regexp is a decoder that only allows inputs matching regexp
 type Regexp struct {
-	cache map[string]*regexp.Regexp
+	cache       map[string]*regexp.Regexp
+	outputCache *lru.Cache[string, []byte]
 }
 
 // Decode only allows inputs matching regexp
 func (r *Regexp) Decode(in []byte, conf config.Decoder) ([]byte, error) {
 	if conf.Regexps == nil {
 		return nil, errors.New("no regexps defined in config")
 	}
+	inputStr := string(in)
 
 	if r.cache == nil {
 		r.cache = map[string]*regexp.Regexp{}
 	}
+	if conf.LruCacheSize > 0 && r.outputCache == nil {
+		outputCache, err := lru.New[string, []byte](conf.LruCacheSize)
+		if err != nil {
+			return nil, err
+		}
+		r.outputCache = outputCache
+	}
 
 	for _, expr := range conf.Regexps {
 		if _, ok := r.cache[expr]; !ok {
@@ -33,16 +43,27 @@ func (r *Regexp) Decode(in []byte, conf config.Decoder) ([]byte, error) {
 			r.cache[expr] = compiled
 		}
 
+		if r.outputCache != nil {
+			if v, ok := r.outputCache.Get(inputStr); ok {
+				return v, nil
+			}
+		}
+
 		matches := r.cache[expr].FindSubmatch(in)
 
-		// First sub-match if present
+		var output []byte
 		if len(matches) == 2 {
-			return matches[1], nil
+			// First sub-match if present
+			output = matches[1]
+		} else if len(matches) == 1 {
+			// General match
+			output = matches[0]
 		}
-
-		// General match
-		if len(matches) == 1 {
-			return matches[0], nil
+		if output != nil {
+			if r.outputCache != nil {
+				r.outputCache.Add(inputStr, output)
+			}
+			return output, nil
 		}
 	}
 

decoder/regexp_test.go

@@ -54,3 +54,19 @@ func TestRegexpDecoder(t *testing.T) {
 		}
 	}
 }
+
+func TestRegexpDecoderWithLru(t *testing.T) {
+	d := &Regexp{}
+	input := []byte("systemd-bananad")
+	expectedOutput := []byte("systemd")
+	out, err := d.Decode(input, config.Decoder{Regexps: []string{"^(systemd).*$", "^syslog-ng$"}, LruCacheSize: 100})
+	if err != nil {
+		t.Errorf("Error decoding %s: %v", input, err)
+	}
+	if !bytes.Equal(out, expectedOutput) {
+		t.Errorf("Expected %s, got %s", expectedOutput, out)
+	}
+	if d.outputCache.Len() != 1 || d.outputCache.Keys()[0] != string(input) {
+		t.Errorf("Error decoding %s: unexpected lru keys %v", input, d.outputCache.Keys())
+	}
+}

examples/regexp.yaml

@@ -8,6 +8,7 @@ metrics:
           decoders:
             - name: string
             - name: regexp
+              lru_cache_size: 100
               regexps:
                 - ^(kswapd).*$ # anything matching kswapd prefix, mapping to one kswapd bucket
                 - ^(systemd.*)$ # anything matching systemd prefix, mapping to one systemd bucket

go.mod

@@ -30,6 +30,7 @@ require (
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1 // indirect
+	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect

go.sum

@@ -30,6 +30,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1 h1:e9Rjr40Z98/clHv5Yg79Is0NtosR5LXRvdr7o/6NwbA=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1/go.mod h1:tIxuGz/9mpox++sgp9fJjHO0+q1X9/UOWd798aAm22M=
+github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
+github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/iovisor/gobpf v0.2.0 h1:34xkQxft+35GagXBk3n23eqhm0v7q0ejeVirb8sqEOQ=
 github.com/iovisor/gobpf v0.2.0/go.mod h1:WSY9Jj5RhdgC3ci1QaacvbFdQ8cbrEjrpiZbLHLt2s4=
 github.com/jaypipes/pcidb v1.0.1 h1:WB2zh27T3nwg8AE8ei81sNRb9yWBii3JGNJtT7K9Oic=