Expose Compile alongside Parse with CEL compilers

caching_compiler.go

@@ -0,0 +1,83 @@
+package expr
+
+import (
+	"sync/atomic"
+	"time"
+
+	"github.com/google/cel-go/cel"
+	"github.com/karlseguin/ccache/v2"
+)
+
+var (
+	CacheTime = time.Hour
+)
+
+// NewCachingCompiler returns a CELCompiler which lifts quoted literals out of the expression
+// as variables and uses caching to cache expression parsing, resulting in improved
+// performance when parsing expressions.
+func NewCachingCompiler(env *cel.Env, cache *ccache.Cache) CELCompiler {
+	return &cachingCompiler{
+		cache: cache,
+		env:   env,
+	}
+}
+
+type cachingCompiler struct {
+	// cache is a global cache of precompiled expressions.
+	cache *ccache.Cache
+
+	env *cel.Env
+
+	hits   int64
+	misses int64
+}
+
+// Parse calls
+func (c *cachingCompiler) Parse(expr string) (*cel.Ast, *cel.Issues, LiftedArgs) {
+	if c.cache == nil {
+		c.cache = ccache.New(ccache.Configure())
+	}
+
+	expr, vars := liftLiterals(expr)
+
+	if cached := c.cache.Get("cc:" + expr); cached != nil {
+		cached.Extend(CacheTime)
+		p := cached.Value().(parsedCELExpr)
+		atomic.AddInt64(&c.hits, 1)
+		return p.AST, p.ParseIssues, vars
+	}
+
+	ast, issues := c.env.Parse(expr)
+
+	c.cache.Set("cc:"+expr, parsedCELExpr{
+		Expr:        expr,
+		AST:         ast,
+		ParseIssues: issues,
+	}, CacheTime)
+
+	atomic.AddInt64(&c.misses, 1)
+	return ast, issues, vars
+}
+
+func (c *cachingCompiler) Compile(expr string) (*cel.Ast, *cel.Issues, LiftedArgs) {
+	ast, issues, args := c.Parse(expr)
+	if issues != nil {
+		return ast, issues, args
+	}
+	ast, issues = c.env.Check(ast)
+	return ast, issues, args
+}
+
+func (c *cachingCompiler) Hits() int64 {
+	return atomic.LoadInt64(&c.hits)
+}
+
+func (c *cachingCompiler) Misses() int64 {
+	return atomic.LoadInt64(&c.misses)
+}
+
+type parsedCELExpr struct {
+	Expr        string
+	AST         *cel.Ast
+	ParseIssues *cel.Issues
+}

caching_parser_test.go → caching_coompiler_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestCachingParser_CachesSame(t *testing.T) {
-	c := cachingParser{env: newEnv()}
+	c := cachingCompiler{env: newEnv()}
 
 	a := `event.data.a == "cache"`
 	b := `event.data.b == "cache"`
@@ -20,7 +20,7 @@ func TestCachingParser_CachesSame(t *testing.T) {
 	)
 
 	t.Run("With an uncached expression", func(t *testing.T) {
-		prevAST, prevIssues, prevVars = c.Parse(a)
+		prevAST, prevIssues, prevVars = c.Compile(a)
 		require.NotNil(t, prevAST)
 		require.Nil(t, prevIssues)
 		require.NotNil(t, prevVars)
@@ -29,7 +29,7 @@ func TestCachingParser_CachesSame(t *testing.T) {
 	})
 
 	t.Run("With a cached expression", func(t *testing.T) {
-		ast, issues, vars := c.Parse(a)
+		ast, issues, vars := c.Compile(a)
 		require.NotNil(t, ast)
 		require.Nil(t, issues)
 
@@ -42,7 +42,7 @@ func TestCachingParser_CachesSame(t *testing.T) {
 	})
 
 	t.Run("With another uncached expression", func(t *testing.T) {
-		prevAST, prevIssues, prevVars = c.Parse(b)
+		prevAST, prevIssues, prevVars = c.Compile(b)
 		require.NotNil(t, prevAST)
 		require.Nil(t, prevIssues)
 		// This misses the cache, as the vars have changed - not the
@@ -52,8 +52,8 @@ func TestCachingParser_CachesSame(t *testing.T) {
 	})
 }
 
-func TestCachingParser_CacheIgnoreLiterals_Unescaped(t *testing.T) {
-	c := cachingParser{env: newEnv()}
+func TestCachingCompile(t *testing.T) {
+	c := cachingCompiler{env: newEnv()}
 
 	a := `event.data.a == "literal-a" && event.data.b == "yes-1"`
 	b := `event.data.a == "literal-b" && event.data.b == "yes-2"`
@@ -65,15 +65,15 @@ func TestCachingParser_CacheIgnoreLiterals_Unescaped(t *testing.T) {
 	)
 
 	t.Run("With an uncached expression", func(t *testing.T) {
-		prevAST, prevIssues, prevVars = c.Parse(a)
+		prevAST, prevIssues, prevVars = c.Compile(a)
 		require.NotNil(t, prevAST)
 		require.Nil(t, prevIssues)
 		require.EqualValues(t, 0, c.Hits())
 		require.EqualValues(t, 1, c.Misses())
 	})
 
 	t.Run("With a cached expression", func(t *testing.T) {
-		ast, issues, vars := c.Parse(a)
+		ast, issues, vars := c.Compile(a)
 		require.NotNil(t, ast)
 		require.Nil(t, issues)
 
@@ -86,55 +86,11 @@ func TestCachingParser_CacheIgnoreLiterals_Unescaped(t *testing.T) {
 	})
 
 	t.Run("With a cached expression having different literals ONLY", func(t *testing.T) {
-		prevAST, prevIssues, _ = c.Parse(b)
+		prevAST, prevIssues, _ = c.Compile(b)
 		require.NotNil(t, prevAST)
 		require.Nil(t, prevIssues)
 		// This misses the cache.
 		require.EqualValues(t, 2, c.Hits())
 		require.EqualValues(t, 1, c.Misses())
 	})
 }
-
-/*
-func TestCachingParser_CacheIgnoreLiterals_Escaped(t *testing.T) {
-	return
-	c := cachingParser{env: newEnv()}
-
-	a := `event.data.a == "literal\"-a" && event.data.b == "yes"`
-	b := `event.data.a == "literal\"-b" && event.data.b == "yes"`
-
-	var (
-		prevAST    *cel.Ast
-		prevIssues *cel.Issues
-	)
-
-	t.Run("With an uncached expression", func(t *testing.T) {
-		prevAST, prevIssues = c.Parse(a)
-		require.NotNil(t, prevAST)
-		require.Nil(t, prevIssues)
-		require.EqualValues(t, 0, c.Hits())
-		require.EqualValues(t, 1, c.Misses())
-	})
-
-	t.Run("With a cached expression", func(t *testing.T) {
-		ast, issues := c.Parse(a)
-		require.NotNil(t, ast)
-		require.Nil(t, issues)
-
-		require.Equal(t, prevAST, ast)
-		require.Equal(t, prevIssues, issues)
-
-		require.EqualValues(t, 1, c.Hits())
-		require.EqualValues(t, 1, c.Misses())
-	})
-
-	t.Run("With a cached expression having different literals ONLY", func(t *testing.T) {
-		prevAST, prevIssues = c.Parse(b)
-		require.NotNil(t, prevAST)
-		require.Nil(t, prevIssues)
-		// This misses the cache.
-		require.EqualValues(t, 2, c.Hits())
-		require.EqualValues(t, 1, c.Misses())
-	})
-}
-*/

evaluable.go

@@ -0,0 +1,25 @@
+package expr
+
+// Evaluable represents an evaluable expression with a unique identifier.
+type Evaluable interface {
+	// GetID returns a unique identifier for the evaluable item.  If there are
+	// two instances of the same expression, the identifier should return a unique
+	// string for each instance of the expression (eg. for two pauses).
+	//
+	// It has the Get prefix to reduce collisions with implementations who expose an
+	// ID member.
+	GetID() string
+
+	// GetExpression returns an expression as a raw string.
+	//
+	// It has the Get prefix to reduce collisions with implementations who expose an
+	// Expression member.
+	GetExpression() string
+}
+
+// StringExpression is a string type that implements Evaluable, useful for basic
+// ephemeral expressions that have no lifetime.
+type StringExpression string
+
+func (s StringExpression) GetID() string         { return string(s) }
+func (s StringExpression) GetExpression() string { return string(s) }

expr.go

@@ -75,23 +75,6 @@ func NewAggregateEvaluator(
 	}
 }
 
-// Evaluable represents an evaluable expression with a unique identifier.
-type Evaluable interface {
-	// GetID returns a unique identifier for the evaluable item.  If there are
-	// two instances of the same expression, the identifier should return a unique
-	// string for each instance of the expression (eg. for two pauses).
-	//
-	// It has the Get prefix to reduce collisions with implementations who expose an
-	// ID member.
-	GetID() string
-
-	// GetExpression returns an expression as a raw string.
-	//
-	// It has the Get prefix to reduce collisions with implementations who expose an
-	// Expression member.
-	GetExpression() string
-}
-
 type aggregator struct {
 	eval   ExpressionEvaluator
 	parser TreeParser

expr_test.go

@@ -16,11 +16,11 @@ import (
 )
 
 func BenchmarkCachingEvaluate1_000(b *testing.B) {
-	benchEval(1_000, NewCachingParser(newEnv(), nil), b)
+	benchEval(1_000, NewCachingCompiler(newEnv(), nil), b)
 }
 
 // func BenchmarkNonCachingEvaluate1_000(b *testing.B) { benchEval(1_000, EnvParser(newEnv()), b) }
-func benchEval(i int, p CELParser, b *testing.B) {
+func benchEval(i int, p CELCompiler, b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		parser := NewTreeParser(p)
 		_ = evaluate(b, i, parser)
@@ -57,7 +57,7 @@ func evaluate(b *testing.B, i int, parser TreeParser) error {
 
 func TestEvaluate_Strings(t *testing.T) {
 	ctx := context.Background()
-	parser := NewTreeParser(NewCachingParser(newEnv(), nil))
+	parser := NewTreeParser(NewCachingCompiler(newEnv(), nil))
 	e := NewAggregateEvaluator(parser, testBoolEvaluator)
 
 	expected := tex(`event.data.account_id == "yes" && event.data.match == "true"`)
@@ -111,7 +111,7 @@ func TestEvaluate_Strings(t *testing.T) {
 
 func TestEvaluate_Concurrently(t *testing.T) {
 	ctx := context.Background()
-	parser := NewTreeParser(NewCachingParser(newEnv(), nil))
+	parser := NewTreeParser(NewCachingCompiler(newEnv(), nil))
 	e := NewAggregateEvaluator(parser, testBoolEvaluator)
 
 	expected := tex(`event.data.account_id == "yes" && event.data.match == "true"`)
@@ -146,7 +146,7 @@ func TestEvaluate_Concurrently(t *testing.T) {
 
 func TestEvaluate_ArrayIndexes(t *testing.T) {
 	ctx := context.Background()
-	parser := NewTreeParser(NewCachingParser(newEnv(), nil))
+	parser := NewTreeParser(NewCachingCompiler(newEnv(), nil))
 	e := NewAggregateEvaluator(parser, testBoolEvaluator)
 
 	expected := tex(`event.data.ids[1] == "id-b" && event.data.ids[2] == "id-c"`)
@@ -192,7 +192,7 @@ func TestEvaluate_ArrayIndexes(t *testing.T) {
 
 func TestEvaluate_Compound(t *testing.T) {
 	ctx := context.Background()
-	parser := NewTreeParser(NewCachingParser(newEnv(), nil))
+	parser := NewTreeParser(NewCachingCompiler(newEnv(), nil))
 	e := NewAggregateEvaluator(parser, testBoolEvaluator)
 
 	expected := tex(`event.data.a == "ok" && event.data.b == "yes" && event.data.c == "please"`)