add EvaluationMeta empty interface to each Result

constraint/pkg/client/drivers/local/driver.go

@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/open-policy-agent/frameworks/constraint/pkg/apis/constraints"
 	"github.com/open-policy-agent/frameworks/constraint/pkg/client/drivers"
@@ -72,6 +73,20 @@ type Driver struct {
 	clientCertWatcher *certwatcher.CertWatcher
 }
 
+// regoResultMeta has rego specific metadata for a result.
+type regoResultMeta struct {
+	// templateRunTime is the number of milliseconds it took to evaluate all constraints for a template.
+	templateRunTime float64
+	// engineType is an engine set string for the kind of underlying engine that was used for a client.Review() call.
+	engineType string
+	// constraintCount indicates how many constraints were evaluated for an underlying engine eval call.
+	constraintCount uint
+}
+
+func (rm *regoResultMeta) EngineStatsString() string {
+	return fmt.Sprintf("totalTemplateRuntime: %.4f, engineType: %s, constraintCount: %d", rm.templateRunTime, rm.engineType, rm.constraintCount)
+}
+
 // AddTemplate adds templ to Driver. Normalizes modules into usable forms for
 // use in queries.
 func (d *Driver) AddTemplate(ctx context.Context, templ *templates.ConstraintTemplate) error {
@@ -238,6 +253,7 @@ func (d *Driver) Query(ctx context.Context, target string, constraints []*unstru
 	defer d.mtx.RUnlock()
 
 	for kind, kindConstraints := range constraintsByKind {
+		evalStartTime := time.Now()
 		compiler := d.compilers.getCompiler(target, kind)
 		if compiler == nil {
 			// The Template was just removed, so the Driver is in an inconsistent
@@ -254,6 +270,7 @@ func (d *Driver) Query(ctx context.Context, target string, constraints []*unstru
 		}
 
 		resultSet, trace, err := d.eval(ctx, compiler, target, path, parsedInput, opts...)
+		evalEndTime := time.Since(evalStartTime)
 		if err != nil {
 			resultSet = make(rego.ResultSet, 0, len(kindConstraints))
 			for _, constraint := range kindConstraints {
@@ -279,6 +296,14 @@ func (d *Driver) Query(ctx context.Context, target string, constraints []*unstru
 			return nil, nil, err
 		}
 
+		for _, result := range kindResults {
+			result.ResultMeta = &regoResultMeta{
+				templateRunTime: float64(evalEndTime.Nanoseconds()) / 1000000,
+				engineType:      "rego",
+				constraintCount: uint(len(kindResults)),
+			}
+		}
+
 		results = append(results, kindResults...)
 	}
 

constraint/pkg/client/drivers/local/driver_unit_test.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"os"
 	"sort"
+	"strings"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -171,6 +172,17 @@ func TestDriver_Query(t *testing.T) {
 	if len(res) == 0 {
 		t.Fatalf("got 0 errors on data-less query; want 1")
 	}
+
+	statsString := res[0].ResultMeta.EngineStatsString()
+	partOfExcpectedStatsString := fmt.Sprintf("engineType: rego, constraintCount: 1")
+	if !strings.Contains(statsString, partOfExcpectedStatsString) {
+		t.Fatalf("did not find expected string: %s, in: %s", partOfExcpectedStatsString, statsString)
+	}
+
+	partOfNonExpectingString := "totalTemplateRuntime: 0.0000"
+	if strings.Contains(statsString, partOfNonExpectingString) {
+		t.Fatalf("did not expect string: %s, in: %s", partOfNonExpectingString, statsString)
+	}
 }
 
 func TestDriver_ExternalData(t *testing.T) {

constraint/pkg/client/e2e_test.go

@@ -3,6 +3,7 @@ package client_test
 import (
 	"context"
 	"errors"
+	"strconv"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -727,3 +728,44 @@ func TestE2E_Tracing(t *testing.T) {
 		})
 	}
 }
+
+// TestE2E_Review_ResultMeta tests that we can get stats out of evaluated constraints.
+func TestE2E_Review_ResultMeta(t *testing.T) {
+	ctx := context.Background()
+	c := clienttest.New(t)
+	ct := clienttest.TemplateCheckData()
+	_, err := c.AddTemplate(ctx, ct)
+	if err != nil {
+		t.Fatal(err)
+	}
+	numConstrains := 3
+
+	for i := 1; i < numConstrains+1; i++ {
+		name := "constraint-" + strconv.Itoa(i)
+		constraint := cts.MakeConstraint(t, clienttest.KindCheckData, name, cts.WantData("bar"))
+		_, err = c.AddConstraint(ctx, constraint)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	review := handlertest.Review{
+		Object: handlertest.Object{
+			Name: "foo",
+			Data: "qux",
+		},
+	}
+
+	responses, err := c.Review(ctx, review)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	results := responses.Results()
+
+	for _, result := range results {
+		if result.ResultMeta.EngineStatsString() == "" {
+			t.Fatalf("expected to have a stats string, got empty string")
+		}
+	}
+}

constraint/pkg/types/validation.go

@@ -23,6 +23,8 @@ type Result struct {
 
 	// The enforcement action of the constraint
 	EnforcementAction string `json:"enforcementAction,omitempty"`
+
+	ResultMeta ResultMeta
 }
 
 // Response is a collection of Constraint violations for a particular Target.
@@ -134,3 +136,13 @@ func (r *Responses) TraceDump() string {
 	}
 	return b.String()
 }
+
+// ResultMeta defines an interface to expose metadata for a Result.
+type ResultMeta interface {
+	// EngineStatsString gives an amorphous representation of engine stats
+	// such as latency, engine type or the number of constraints evalauted
+	// against a template. The underlying enigne type defines and implements
+	// structs for this interface. This function is primarily inteded for logging
+	// out for the consumers of this library.
+	EngineStatsString() string
+}