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"
@@ -238,6 +239,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 +256,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 +282,12 @@ func (d *Driver) Query(ctx context.Context, target string, constraints []*unstru
 			return nil, nil, err
 		}
 
+		for _, result := range kindResults {
+			result.ResultMeta = &types.ResultMeta{
+				ReviewMeta: types.NewReviewMeta(float64(evalEndTime.Nanoseconds())/1000000, types.RegoEngine, uint(len(kindResults))),
+			}
+		}
+
 		results = append(results, kindResults...)
 	}
 

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

@@ -171,6 +171,11 @@ func TestDriver_Query(t *testing.T) {
 	if len(res) == 0 {
 		t.Fatalf("got 0 errors on data-less query; want 1")
 	}
+
+	expectingStatsString := fmt.Sprintf("evaluationLatency: %.4f, engineType: rego, batchSize: 1", res[0].GetEvaluationLatency())
+	if res[0].GetStatsString() == expectingStatsString {
+		t.Fatalf("did not receive expected StatsString; want: %s, got: %s", expectingStatsString, res[0].GetStatsString())
+	}
 }
 
 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_ResponseMeta tests that we can get stats out of evaluated constraints.
+func TestE2E_Review_ResponseMeta(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.GetStatsString() == "" {
+			t.Fatalf("expected to have a stats string, got empty string")
+		}
+	}
+}

constraint/pkg/types/validation.go

@@ -9,6 +9,27 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 )
 
+type EvaluationEngineType string
+
+const (
+	Undefined  EvaluationEngineType = "undefined"
+	RegoEngine EvaluationEngineType = "rego"
+)
+
+type ReviewMeta struct {
+	// evaluationLatency is the number of milliseconds it took to server a client.Review() call.
+	evaluationLatency float64
+	// engineType denotes an enum for which kind of underlying engine was used for a client.Review() call.
+	engineType EvaluationEngineType
+	// batchSize indicates how many constrains were evaluated for an underlying engine eval call.
+	batchSize uint
+}
+
+// ResultMeta coontains metadata, such as latency, etc., for a given Response.
+type ResultMeta struct {
+	*ReviewMeta `json:"reviewMeta,inline"`
+}
+
 type Result struct {
 	// Target is the target this violation is for.
 	Target string `json:"target"`
@@ -23,6 +44,8 @@ type Result struct {
 
 	// The enforcement action of the constraint
 	EnforcementAction string `json:"enforcementAction,omitempty"`
+
+	*ResultMeta `json:"-,inline"`
 }
 
 // Response is a collection of Constraint violations for a particular Target.
@@ -134,3 +157,27 @@ func (r *Responses) TraceDump() string {
 	}
 	return b.String()
 }
+
+type engineStats interface {
+	GetStatsString() string
+	GetEvaluationLatency() float64
+}
+
+// GetStatsString gives a ReviewMeta representation for logging.
+func (rm *ReviewMeta) GetStatsString() string {
+	return fmt.Sprintf("evaluationLatency: %.4f, engineType: %s, batchSize: %d", rm.evaluationLatency, rm.engineType, rm.batchSize)
+}
+
+// GetEvaluationLatency gets the latency spent evaluating a result.
+// Note that this latencyof a result latencies batched together.
+func (rm *ReviewMeta) GetEvaluationLatency() float64 {
+	return rm.evaluationLatency
+}
+
+func NewReviewMeta(latency float64, engine EvaluationEngineType, batch uint) *ReviewMeta {
+	return &ReviewMeta{
+		evaluationLatency: latency,
+		engineType:        engine,
+		batchSize:         batch,
+	}
+}