attach coverage to a gRPC error detail on failure

Signed-off-by: Kartik Joshi <karikjoshi21@gmail.com>

Author: kartikjoshi21

cmd/frontend/coverage.go

@@ -10,12 +10,7 @@ import (
 	"runtime/coverage"
 
 	gwclient "github.com/moby/buildkit/frontend/gateway/client"
-)
-
-const (
-	frontendCoverageOptKey = "dalec.coverage"
-	frontendCovMetaKey     = "dalec.coverage.frontend.meta.gz"
-	frontendCovCountersKey = "dalec.coverage.frontend.counters.gz"
+	"github.com/project-dalec/dalec/internal/frontendcoverage"
 )
 
 func isNoMetaErr(err error) bool {
@@ -26,14 +21,9 @@ func isNoMetaErr(err error) bool {
 	return strings.Contains(strings.ToLower(err.Error()), "no meta-data available")
 }
 
-// Enabled per solve via SolveRequest.FrontendOpt["dalec.coverage"]="1"
+// Enabled per solve via SolveRequest.FrontendOpt[frontendcoverage.OptKey]="1"
 func wantFrontendCoverage(c gwclient.Client) bool {
-	v, ok := c.BuildOpts().Opts[frontendCoverageOptKey]
-	if !ok {
-		return false
-	}
-	v = strings.ToLower(strings.TrimSpace(v))
-	return v == "1" || v == "true" || v == "yes" || v == "on"
+	return frontendcoverage.Want(c.BuildOpts().Opts)
 }
 
 func gzipBytes(in []byte) ([]byte, error) {
@@ -49,65 +39,74 @@ func gzipBytes(in []byte) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-func attachFrontendCoverage(c gwclient.Client, res *gwclient.Result) error {
-	if res == nil || !wantFrontendCoverage(c) {
-		return nil
-	}
-	if res.Metadata == nil {
-		res.Metadata = map[string][]byte{}
-	}
+var frontendCoverageCollector = collectFrontendCoveragePayload
 
+func collectFrontendCoveragePayload() (*frontendcoverage.Payload, error) {
 	var metaBuf, ctrBuf bytes.Buffer
 
 	if err := coverage.WriteMeta(&metaBuf); err != nil {
 		if isNoMetaErr(err) {
-			return nil
+			return nil, nil
 		}
-		return err
+		return nil, err
 	}
 	if err := coverage.WriteCounters(&ctrBuf); err != nil {
 		if isNoMetaErr(err) {
-			return nil
+			return nil, nil
 		}
-		return err
+		return nil, err
 	}
 
 	metaGz, err := gzipBytes(metaBuf.Bytes())
 	if err != nil {
-		return err
+		return nil, err
 	}
 	ctrGz, err := gzipBytes(ctrBuf.Bytes())
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	res.Metadata[frontendCovMetaKey] = metaGz
-	res.Metadata[frontendCovCountersKey] = ctrGz
-
 	// Avoid cross-solve accumulation if the frontend process is reused.
 	// Only works for binaries built with -cover (and typically atomic counters).
 	_ = coverage.ClearCounters()
 
-	return nil
+	return &frontendcoverage.Payload{
+		MetaGz:     metaGz,
+		CountersGz: ctrGz,
+	}, nil
 }
 
 func wrapWithCoverage(next gwclient.BuildFunc) gwclient.BuildFunc {
 	return func(ctx context.Context, c gwclient.Client) (*gwclient.Result, error) {
 		res, err := next(ctx, c)
-
-		// If coverage is requested, make sure we have a result object to attach
-		// metadata to even on error paths.
-		if wantFrontendCoverage(c) && res == nil {
-			res = gwclient.NewResult()
+		if !wantFrontendCoverage(c) {
+			return res, err
 		}
 
-		if covErr := attachFrontendCoverage(c, res); covErr != nil {
+		payload, covErr := frontendCoverageCollector()
+		if covErr != nil {
 			if err != nil {
 				return res, errors.Join(err, covErr)
 			}
 			return res, covErr
 		}
+		if payload == nil {
+			return res, err
+		}
+
+		if err != nil {
+			errWithCoverage, attachErr := payload.AttachToError(err)
+			if attachErr != nil {
+				return res, errors.Join(err, attachErr)
+			}
+			return res, errWithCoverage
+		}
+
+		if res == nil {
+			res = gwclient.NewResult()
+		}
+		payload.AttachToResult(res)
 
-		return res, err
+		return res, nil
 	}
 }

cmd/frontend/coverage_test.go

@@ -0,0 +1,132 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/moby/buildkit/client/llb"
+	"github.com/moby/buildkit/client/llb/sourceresolver"
+	gwclient "github.com/moby/buildkit/frontend/gateway/client"
+	"github.com/moby/buildkit/solver/pb"
+	digest "github.com/opencontainers/go-digest"
+	"github.com/project-dalec/dalec/internal/frontendcoverage"
+)
+
+func TestWrapWithCoverageAttachesResultMetadataOnSuccess(t *testing.T) {
+	t.Cleanup(setFrontendCoverageCollectorForTest(func() (*frontendcoverage.Payload, error) {
+		return &frontendcoverage.Payload{
+			MetaGz:     []byte("meta-gz"),
+			CountersGz: []byte("counters-gz"),
+		}, nil
+	}))
+
+	res, err := wrapWithCoverage(func(context.Context, gwclient.Client) (*gwclient.Result, error) {
+		return nil, nil
+	})(context.Background(), &fakeGatewayClient{
+		opts: map[string]string{frontendcoverage.OptKey: "1"},
+	})
+	if err != nil {
+		t.Fatalf("expected nil error, got %v", err)
+	}
+	if res == nil {
+		t.Fatal("expected result to be created when coverage is enabled")
+	}
+
+	payload, payloadErr := frontendcoverage.PayloadFromSolve(res, nil)
+	if payloadErr != nil {
+		t.Fatalf("expected nil payload error, got %v", payloadErr)
+	}
+	if payload == nil {
+		t.Fatal("expected payload to be attached to result metadata")
+	}
+	if !bytes.Equal(payload.MetaGz, []byte("meta-gz")) {
+		t.Fatalf("unexpected meta payload: %q", payload.MetaGz)
+	}
+	if !bytes.Equal(payload.CountersGz, []byte("counters-gz")) {
+		t.Fatalf("unexpected counters payload: %q", payload.CountersGz)
+	}
+}
+
+func TestWrapWithCoverageAttachesGRPCDetailOnError(t *testing.T) {
+	t.Cleanup(setFrontendCoverageCollectorForTest(func() (*frontendcoverage.Payload, error) {
+		return &frontendcoverage.Payload{
+			MetaGz:     []byte("meta-gz"),
+			CountersGz: []byte("counters-gz"),
+		}, nil
+	}))
+
+	frontendErr := errors.New("frontend failed")
+	res, err := wrapWithCoverage(func(context.Context, gwclient.Client) (*gwclient.Result, error) {
+		return nil, frontendErr
+	})(context.Background(), &fakeGatewayClient{
+		opts: map[string]string{frontendcoverage.OptKey: "1"},
+	})
+	if res != nil {
+		t.Fatal("expected nil result on error path")
+	}
+	if err == nil {
+		t.Fatal("expected error from wrapped frontend")
+	}
+	if !errors.Is(err, frontendErr) {
+		t.Fatalf("expected wrapped error to preserve original error, got %v", err)
+	}
+	if err.Error() != frontendErr.Error() {
+		t.Fatalf("expected wrapped error message %q, got %q", frontendErr.Error(), err.Error())
+	}
+
+	payload, payloadErr := frontendcoverage.PayloadFromError(err)
+	if payloadErr != nil {
+		t.Fatalf("expected nil payload error, got %v", payloadErr)
+	}
+	if payload == nil {
+		t.Fatal("expected payload to be attached to error details")
+	}
+	if !bytes.Equal(payload.MetaGz, []byte("meta-gz")) {
+		t.Fatalf("unexpected meta payload: %q", payload.MetaGz)
+	}
+	if !bytes.Equal(payload.CountersGz, []byte("counters-gz")) {
+		t.Fatalf("unexpected counters payload: %q", payload.CountersGz)
+	}
+}
+
+func setFrontendCoverageCollectorForTest(f func() (*frontendcoverage.Payload, error)) func() {
+	previous := frontendCoverageCollector
+	frontendCoverageCollector = f
+	return func() {
+		frontendCoverageCollector = previous
+	}
+}
+
+type fakeGatewayClient struct {
+	opts map[string]string
+}
+
+func (c *fakeGatewayClient) Solve(context.Context, gwclient.SolveRequest) (*gwclient.Result, error) {
+	panic("unexpected call to Solve")
+}
+
+func (c *fakeGatewayClient) ResolveImageConfig(context.Context, string, sourceresolver.Opt) (string, digest.Digest, []byte, error) {
+	panic("unexpected call to ResolveImageConfig")
+}
+
+func (c *fakeGatewayClient) ResolveSourceMetadata(context.Context, *pb.SourceOp, sourceresolver.Opt) (*sourceresolver.MetaResponse, error) {
+	panic("unexpected call to ResolveSourceMetadata")
+}
+
+func (c *fakeGatewayClient) BuildOpts() gwclient.BuildOpts {
+	return gwclient.BuildOpts{Opts: c.opts}
+}
+
+func (c *fakeGatewayClient) Inputs(context.Context) (map[string]llb.State, error) {
+	panic("unexpected call to Inputs")
+}
+
+func (c *fakeGatewayClient) NewContainer(context.Context, gwclient.NewContainerRequest) (gwclient.Container, error) {
+	panic("unexpected call to NewContainer")
+}
+
+func (c *fakeGatewayClient) Warn(context.Context, digest.Digest, string, gwclient.WarnOpts) error {
+	panic("unexpected call to Warn")
+}